RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 12:37:44 +00:00
Code Issues Activity Actions

LibDNS: Remove the 'DNS' prefix from the various type and class names

Browse source 
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:
Tom 2022-04-14 16:58:40 -06:00 • committed by Linus Groh
parent a3a1fe833b
commit 49de4d5f33
17 changed files with 219 additions and 219 deletions
Download patch file Download diff file Expand all files Collapse all files

42
Userland/Libraries/LibDNS/DNSAnswer.cpp → Userland/Libraries/LibDNS/Answer.cpp
View file

@ -4,7 +4,7 @@
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
*/ */
#include "DNSAnswer.h" #include "Answer.h"
#include <AK/Stream.h> #include <AK/Stream.h>
#include <LibIPC/Decoder.h> #include <LibIPC/Decoder.h>
#include <LibIPC/Encoder.h> #include <LibIPC/Encoder.h>
@ -12,7 +12,7 @@
namespace DNS { 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_name(name)
, m_type(type) , m_type(type)
, m_class_code(class_code) , m_class_code(class_code)
@ -23,12 +23,12 @@ DNSAnswer::DNSAnswer(DNSName const& name, DNSRecordType type, DNSRecordClass cla
time(&m_received_time); time(&m_received_time);
} }
bool DNSAnswer::has_expired() const bool Answer::has_expired() const
{ {
return time(nullptr) >= m_received_time + m_ttl; 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()); auto hash = pair_int_hash(CaseInsensitiveStringTraits::hash(name().as_string()), (u32)type());
hash = pair_int_hash(hash, pair_int_hash((u32)class_code(), ttl())); hash = pair_int_hash(hash, pair_int_hash((u32)class_code(), ttl()));
@ -37,11 +37,11 @@ unsigned DNSAnswer::hash() const
return hash; return hash;
} }
bool DNSAnswer::operator==(DNSAnswer const& other) const bool Answer::operator==(Answer const& other) const
{ {
if (&other == this) if (&other == this)
return true; return true;
if (!DNSName::Traits::equals(name(), other.name())) if (!Name::Traits::equals(name(), other.name()))
return false; return false;
if (type() != other.type()) if (type() != other.type())
return false; 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) { switch (value) {
case DNS::DNSRecordType::A: case DNS::RecordType::A:
return builder.put_string("A"); return builder.put_string("A");
case DNS::DNSRecordType::NS: case DNS::RecordType::NS:
return builder.put_string("NS"); return builder.put_string("NS");
case DNS::DNSRecordType::CNAME: case DNS::RecordType::CNAME:
return builder.put_string("CNAME"); return builder.put_string("CNAME");
case DNS::DNSRecordType::SOA: case DNS::RecordType::SOA:
return builder.put_string("SOA"); return builder.put_string("SOA");
case DNS::DNSRecordType::PTR: case DNS::RecordType::PTR:
return builder.put_string("PTR"); return builder.put_string("PTR");
case DNS::DNSRecordType::MX: case DNS::RecordType::MX:
return builder.put_string("MX"); return builder.put_string("MX");
case DNS::DNSRecordType::TXT: case DNS::RecordType::TXT:
return builder.put_string("TXT"); return builder.put_string("TXT");
case DNS::DNSRecordType::AAAA: case DNS::RecordType::AAAA:
return builder.put_string("AAAA"); return builder.put_string("AAAA");
case DNS::DNSRecordType::SRV: case DNS::RecordType::SRV:
return builder.put_string("SRV"); return builder.put_string("SRV");
} }
@ -86,10 +86,10 @@ ErrorOr<void> AK::Formatter<DNS::DNSRecordType>::format(AK::FormatBuilder& build
return {}; 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) { switch (value) {
case DNS::DNSRecordClass::IN: case DNS::RecordClass::IN:
return builder.put_string("IN"); return builder.put_string("IN");
} }
@ -100,13 +100,13 @@ ErrorOr<void> AK::Formatter<DNS::DNSRecordClass>::format(AK::FormatBuilder& buil
namespace IPC { 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(); encoder << answer.name().as_string() << (u16)answer.type() << (u16)answer.class_code() << answer.ttl() << answer.record_data() << answer.mdns_cache_flush();
return true; return true;
} }
ErrorOr<void> decode(Decoder& decoder, DNS::DNSAnswer& answer) ErrorOr<void> decode(Decoder& decoder, DNS::Answer& answer)
{ {
String name; String name;
TRY(decoder.decode(name)); TRY(decoder.decode(name));
@ -119,7 +119,7 @@ ErrorOr<void> decode(Decoder& decoder, DNS::DNSAnswer& answer)
TRY(decoder.decode(record_data)); TRY(decoder.decode(record_data));
bool cache_flush; bool cache_flush;
TRY(decoder.decode(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 {}; return {};
} }

42
Userland/Libraries/LibDNS/DNSAnswer.h → Userland/Libraries/LibDNS/Answer.h
View file

@ -6,7 +6,7 @@
#pragma once #pragma once
#include "DNSName.h" #include "Name.h"
#include <AK/Format.h> #include <AK/Format.h>
#include <AK/String.h> #include <AK/String.h>
#include <AK/Traits.h> #include <AK/Traits.h>
@ -15,7 +15,7 @@
namespace DNS { namespace DNS {
enum class DNSRecordType : u16 { enum class RecordType : u16 {
A = 1, A = 1,
NS = 2, NS = 2,
CNAME = 5, CNAME = 5,
@ -27,20 +27,20 @@ enum class DNSRecordType : u16 {
SRV = 33, SRV = 33,
}; };
enum class DNSRecordClass : u16 { enum class RecordClass : u16 {
IN = 1 IN = 1
}; };
#define MDNS_CACHE_FLUSH 0x8000 #define MDNS_CACHE_FLUSH 0x8000
class DNSAnswer { class Answer {
public: public:
DNSAnswer() = default; Answer() = default;
DNSAnswer(DNSName const& name, DNSRecordType type, DNSRecordClass class_code, u32 ttl, String const& record_data, bool mdns_cache_flush); 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; } Name const& name() const { return m_name; }
DNSRecordType type() const { return m_type; } RecordType type() const { return m_type; }
DNSRecordClass class_code() const { return m_class_code; } 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); } u16 raw_class_code() const { return (u16)m_class_code | (m_mdns_cache_flush ? MDNS_CACHE_FLUSH : 0); }
u32 ttl() const { return m_ttl; } u32 ttl() const { return m_ttl; }
time_t received_time() const { return m_received_time; } time_t received_time() const { return m_received_time; }
@ -50,12 +50,12 @@ public:
bool has_expired() const; bool has_expired() const;
unsigned hash() const; unsigned hash() const;
bool operator==(DNSAnswer const&) const; bool operator==(Answer const&) const;
private: private:
DNSName m_name; Name m_name;
DNSRecordType m_type { 0 }; RecordType m_type { 0 };
DNSRecordClass m_class_code { 0 }; RecordClass m_class_code { 0 };
u32 m_ttl { 0 }; u32 m_ttl { 0 };
time_t m_received_time { 0 }; time_t m_received_time { 0 };
String m_record_data; String m_record_data;
@ -65,36 +65,36 @@ private:
} }
template<> 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 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<> template<>
struct AK::Formatter<DNS::DNSRecordType> : StandardFormatter { struct AK::Formatter<DNS::RecordType> : StandardFormatter {
Formatter() = default; Formatter() = default;
explicit Formatter(StandardFormatter formatter) explicit Formatter(StandardFormatter formatter)
: StandardFormatter(formatter) : StandardFormatter(formatter)
{ {
} }
ErrorOr<void> format(AK::FormatBuilder&, DNS::DNSRecordType); ErrorOr<void> format(AK::FormatBuilder&, DNS::RecordType);
}; };
template<> template<>
struct AK::Formatter<DNS::DNSRecordClass> : StandardFormatter { struct AK::Formatter<DNS::RecordClass> : StandardFormatter {
Formatter() = default; Formatter() = default;
explicit Formatter(StandardFormatter formatter) explicit Formatter(StandardFormatter formatter)
: StandardFormatter(formatter) : StandardFormatter(formatter)
{ {
} }
ErrorOr<void> format(AK::FormatBuilder&, DNS::DNSRecordClass); ErrorOr<void> format(AK::FormatBuilder&, DNS::RecordClass);
}; };
namespace IPC { namespace IPC {
bool encode(Encoder&, DNS::DNSAnswer const&); bool encode(Encoder&, DNS::Answer const&);
ErrorOr<void> decode(Decoder&, DNS::DNSAnswer&); ErrorOr<void> decode(Decoder&, DNS::Answer&);
} }

6
Userland/Libraries/LibDNS/CMakeLists.txt
View file

@ -1,7 +1,7 @@
set(SOURCES set(SOURCES
DNSAnswer.cpp Answer.cpp
DNSName.cpp Name.cpp
DNSPacket.cpp Packet.cpp
) )
serenity_lib(LibDNS dns) serenity_lib(LibDNS dns)

49
Userland/Libraries/LibDNS/DNSName.h
View file

@ -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());
}
};

16
Userland/Libraries/LibDNS/DNSName.cpp → Userland/Libraries/LibDNS/Name.cpp
View file

@ -5,14 +5,14 @@
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
*/ */
#include "DNSName.h" #include "Name.h"
#include <AK/Random.h> #include <AK/Random.h>
#include <AK/Vector.h> #include <AK/Vector.h>
#include <ctype.h> #include <ctype.h>
namespace DNS { namespace DNS {
DNSName::DNSName(String const& name) Name::Name(String const& name)
{ {
if (name.ends_with('.')) if (name.ends_with('.'))
m_name = name.substring(0, name.length() - 1); m_name = name.substring(0, name.length() - 1);
@ -20,7 +20,7 @@ DNSName::DNSName(String const& name)
m_name = 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) if (recursion_level > 4)
return {}; 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()) if (m_name.is_empty())
return 1; return 1;
return m_name.length() + 2; return m_name.length() + 2;
} }
void DNSName::randomize_case() void Name::randomize_case()
{ {
StringBuilder builder; StringBuilder builder;
for (char c : m_name) { for (char c : m_name) {
@ -75,7 +75,7 @@ void DNSName::randomize_case()
m_name = builder.to_string(); 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('.'); auto parts = name.as_string().split_view('.');
for (auto& part : parts) { for (auto& part : parts) {
@ -86,12 +86,12 @@ OutputStream& operator<<(OutputStream& stream, DNSName const& name)
return stream; return stream;
} }
unsigned DNSName::Traits::hash(DNSName const& name) unsigned Name::Traits::hash(Name const& name)
{ {
return CaseInsensitiveStringTraits::hash(name.as_string()); 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()); return CaseInsensitiveStringTraits::equals(a.as_string(), b.as_string());
} }

49
Userland/Libraries/LibDNS/Name.h Normal file
View 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());
}
};

54
Userland/Libraries/LibDNS/DNSPacket.cpp → Userland/Libraries/LibDNS/Packet.cpp
View file

@ -5,9 +5,9 @@
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
*/ */
#include "DNSPacket.h" #include "Packet.h"
#include "DNSName.h" #include "Name.h"
#include "DNSPacketHeader.h" #include "PacketHeader.h"
#include <AK/Debug.h> #include <AK/Debug.h>
#include <AK/MemoryStream.h> #include <AK/MemoryStream.h>
#include <AK/StringBuilder.h> #include <AK/StringBuilder.h>
@ -16,23 +16,23 @@
namespace DNS { namespace DNS {
void DNSPacket::add_question(DNSQuestion const& question) void Packet::add_question(Question const& question)
{ {
m_questions.empend(question); m_questions.empend(question);
VERIFY(m_questions.size() <= UINT16_MAX); VERIFY(m_questions.size() <= UINT16_MAX);
} }
void DNSPacket::add_answer(DNSAnswer const& answer) void Packet::add_answer(Answer const& answer)
{ {
m_answers.empend(answer); m_answers.empend(answer);
VERIFY(m_answers.size() <= UINT16_MAX); 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); header.set_id(m_id);
if (is_query()) if (is_query())
header.set_is_query(); header.set_is_query();
@ -62,8 +62,8 @@ ByteBuffer DNSPacket::to_byte_buffer() const
stream << htons((u16)answer.type()); stream << htons((u16)answer.type());
stream << htons(answer.raw_class_code()); stream << htons(answer.raw_class_code());
stream << htonl(answer.ttl()); stream << htonl(answer.ttl());
if (answer.type() == DNSRecordType::PTR) { if (answer.type() == RecordType::PTR) {
DNSName name { answer.record_data() }; Name name { answer.record_data() };
stream << htons(name.serialized_size()); stream << htons(name.serialized_size());
stream << name; stream << name;
} else { } else {
@ -96,21 +96,21 @@ private:
static_assert(sizeof(DNSRecordWithoutName) == 10); 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)) { if (raw_size < sizeof(PacketHeader)) {
dbgln("DNS response not large enough ({} out of {}) to be a DNS packet.", raw_size, sizeof(DNSPacketHeader)); dbgln("DNS response not large enough ({} out of {}) to be a DNS packet.", raw_size, sizeof(PacketHeader));
return {}; 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, "Got packet (ID: {})", header.id());
dbgln_if(LOOKUPSERVER_DEBUG, " Question count: {}", header.question_count()); dbgln_if(LOOKUPSERVER_DEBUG, " Question count: {}", header.question_count());
dbgln_if(LOOKUPSERVER_DEBUG, " Answer count: {}", header.answer_count()); dbgln_if(LOOKUPSERVER_DEBUG, " Answer count: {}", header.answer_count());
dbgln_if(LOOKUPSERVER_DEBUG, " Authority count: {}", header.authority_count()); dbgln_if(LOOKUPSERVER_DEBUG, " Authority count: {}", header.authority_count());
dbgln_if(LOOKUPSERVER_DEBUG, "Additional count: {}", header.additional_count()); dbgln_if(LOOKUPSERVER_DEBUG, "Additional count: {}", header.additional_count());
DNSPacket packet; Packet packet;
packet.m_id = header.id(); packet.m_id = header.id();
packet.m_query_or_response = header.is_response(); packet.m_query_or_response = header.is_response();
packet.m_code = header.response_code(); 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) if (packet.code() != Code::NOERROR)
return packet; return packet;
size_t offset = sizeof(DNSPacketHeader); size_t offset = sizeof(PacketHeader);
for (u16 i = 0; i < header.question_count(); i++) { 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 { struct RawDNSAnswerQuestion {
NetworkOrdered<u16> record_type; NetworkOrdered<u16> record_type;
NetworkOrdered<u16> class_code; 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]; auto& record_and_class = *(RawDNSAnswerQuestion const*)&raw_data[offset];
u16 class_code = record_and_class.class_code & ~MDNS_WANTS_UNICAST_RESPONSE; 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; 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; offset += 4;
auto& question = packet.m_questions.last(); auto& question = packet.m_questions.last();
dbgln_if(LOOKUPSERVER_DEBUG, "Question #{}: name=_{}_, type={}, class={}", i, question.name(), question.record_type(), question.class_code()); 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) { 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]); 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); offset += sizeof(DNSRecordWithoutName);
switch ((DNSRecordType)record.type()) { switch ((RecordType)record.type()) {
case DNSRecordType::PTR: { case RecordType::PTR: {
size_t dummy_offset = offset; 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; break;
} }
case DNSRecordType::CNAME: case RecordType::CNAME:
// Fall through // Fall through
case DNSRecordType::A: case RecordType::A:
// Fall through // Fall through
case DNSRecordType::TXT: case RecordType::TXT:
// Fall through // Fall through
case DNSRecordType::AAAA: case RecordType::AAAA:
// Fall through // Fall through
case DNSRecordType::SRV: case RecordType::SRV:
data = { record.data(), record.data_length() }; data = { record.data(), record.data_length() };
break; break;
default: 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); 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; u16 class_code = record.record_class() & ~MDNS_CACHE_FLUSH;
bool mdns_cache_flush = 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(); offset += record.data_length();
} }

22
Userland/Libraries/LibDNS/DNSPacket.h → Userland/Libraries/LibDNS/Packet.h
View file

@ -7,8 +7,8 @@
#pragma once #pragma once
#include "DNSAnswer.h" #include "Answer.h"
#include "DNSQuestion.h" #include "Question.h"
#include <AK/Optional.h> #include <AK/Optional.h>
#include <AK/Types.h> #include <AK/Types.h>
#include <AK/Vector.h> #include <AK/Vector.h>
@ -20,11 +20,11 @@ enum class ShouldRandomizeCase {
Yes Yes
}; };
class DNSPacket { class Packet {
public: 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; ByteBuffer to_byte_buffer() const;
bool is_query() const { return !m_query_or_response; } bool is_query() const { return !m_query_or_response; }
@ -41,8 +41,8 @@ public:
u16 id() const { return m_id; } u16 id() const { return m_id; }
void set_id(u16 id) { m_id = id; } void set_id(u16 id) { m_id = id; }
Vector<DNSQuestion> const& questions() const { return m_questions; } Vector<Question> const& questions() const { return m_questions; }
Vector<DNSAnswer> const& answers() const { return m_answers; } Vector<Answer> const& answers() const { return m_answers; }
u16 question_count() const u16 question_count() const
{ {
@ -56,8 +56,8 @@ public:
return m_answers.size(); return m_answers.size();
} }
void add_question(DNSQuestion const&); void add_question(Question const&);
void add_answer(DNSAnswer const&); void add_answer(Answer const&);
enum class Code : u8 { enum class Code : u8 {
NOERROR = 0, NOERROR = 0,
@ -82,8 +82,8 @@ private:
bool m_query_or_response { false }; bool m_query_or_response { false };
bool m_recursion_desired { true }; bool m_recursion_desired { true };
bool m_recursion_available { true }; bool m_recursion_available { true };
Vector<DNSQuestion> m_questions; Vector<Question> m_questions;
Vector<DNSAnswer> m_answers; Vector<Answer> m_answers;
}; };
} }

6
Userland/Libraries/LibDNS/DNSPacketHeader.h → Userland/Libraries/LibDNS/PacketHeader.h
View file

@ -11,9 +11,9 @@
namespace DNS { namespace DNS {
class [[gnu::packed]] DNSPacketHeader { class [[gnu::packed]] PacketHeader {
public: public:
DNSPacketHeader() PacketHeader()
: m_recursion_desired(false) : m_recursion_desired(false)
, m_truncated(false) , m_truncated(false)
, m_authoritative_answer(false) , m_authoritative_answer(false)
@ -94,6 +94,6 @@ private:
NetworkOrdered<u16> m_additional_count; NetworkOrdered<u16> m_additional_count;
}; };
static_assert(sizeof(DNSPacketHeader) == 12); static_assert(sizeof(PacketHeader) == 12);
} }

18
Userland/Libraries/LibDNS/DNSQuestion.h → Userland/Libraries/LibDNS/Question.h
View file

@ -6,16 +6,16 @@
#pragma once #pragma once
#include "DNSName.h" #include "Name.h"
#include <AK/Types.h> #include <AK/Types.h>
namespace DNS { namespace DNS {
#define MDNS_WANTS_UNICAST_RESPONSE 0x8000 #define MDNS_WANTS_UNICAST_RESPONSE 0x8000
class DNSQuestion { class Question {
public: 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_name(name)
, m_record_type(record_type) , m_record_type(record_type)
, m_class_code(class_code) , m_class_code(class_code)
@ -23,16 +23,16 @@ public:
{ {
} }
DNSRecordType record_type() const { return m_record_type; } RecordType record_type() const { return m_record_type; }
DNSRecordClass class_code() const { return m_class_code; } 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); } 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; } bool mdns_wants_unicast_response() const { return m_mdns_wants_unicast_response; }
private: private:
DNSName m_name; Name m_name;
DNSRecordType m_record_type { 0 }; RecordType m_record_type { 0 };
DNSRecordClass m_class_code { 0 }; RecordClass m_class_code { 0 };
bool m_mdns_wants_unicast_response { false }; bool m_mdns_wants_unicast_response { false };
}; };

2
Userland/Libraries/LibTLS/Certificate.cpp
View file

@ -409,7 +409,7 @@ Optional<Certificate> Certificate::parse_asn1(ReadonlyBytes buffer, bool)
break; break;
case 2: { case 2: {
// DNS Name // 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); certificate.SAN.append(name);
break; break;
} }

6
Userland/Services/LookupServer/ConnectionFromClient.cpp
View file

@ -7,7 +7,7 @@
#include "ConnectionFromClient.h" #include "ConnectionFromClient.h"
#include "LookupServer.h" #include "LookupServer.h"
#include <AK/IPv4Address.h> #include <AK/IPv4Address.h>
#include <LibDNS/DNSPacket.h> #include <LibDNS/Packet.h>
namespace LookupServer { namespace LookupServer {
@ -28,7 +28,7 @@ void ConnectionFromClient::die()
Messages::LookupServer::LookupNameResponse ConnectionFromClient::lookup_name(String const& name) Messages::LookupServer::LookupNameResponse ConnectionFromClient::lookup_name(String const& name)
{ {
auto maybe_answers = LookupServer::the().lookup(name, DNSRecordType::A); auto maybe_answers = LookupServer::the().lookup(name, RecordType::A);
if (maybe_answers.is_error()) { if (maybe_answers.is_error()) {
dbgln("LookupServer: Failed to lookup A record: {}", maybe_answers.error()); dbgln("LookupServer: Failed to lookup A record: {}", maybe_answers.error());
return { 1, {} }; return { 1, {} };
@ -53,7 +53,7 @@ Messages::LookupServer::LookupAddressResponse ConnectionFromClient::lookup_addre
ip_address[1], ip_address[1],
ip_address[0]); ip_address[0]);
auto maybe_answers = LookupServer::the().lookup(name, DNSRecordType::PTR); auto maybe_answers = LookupServer::the().lookup(name, RecordType::PTR);
if (maybe_answers.is_error()) { if (maybe_answers.is_error()) {
dbgln("LookupServer: Failed to lookup PTR record: {}", maybe_answers.error()); dbgln("LookupServer: Failed to lookup PTR record: {}", maybe_answers.error());
return { 1, String() }; return { 1, String() };

12
Userland/Services/LookupServer/DNSServer.cpp
View file

@ -7,7 +7,7 @@
#include "DNSServer.h" #include "DNSServer.h"
#include "LookupServer.h" #include "LookupServer.h"
#include <AK/IPv4Address.h> #include <AK/IPv4Address.h>
#include <LibDNS/DNSPacket.h> #include <LibDNS/Packet.h>
namespace LookupServer { namespace LookupServer {
@ -29,7 +29,7 @@ ErrorOr<void> DNSServer::handle_client()
{ {
sockaddr_in client_address; sockaddr_in client_address;
auto buffer = receive(1024, client_address); auto buffer = receive(1024, client_address);
auto optional_request = DNSPacket::from_raw_packet(buffer.data(), buffer.size()); auto optional_request = Packet::from_raw_packet(buffer.data(), buffer.size());
if (!optional_request.has_value()) { if (!optional_request.has_value()) {
dbgln("Got an invalid DNS packet"); dbgln("Got an invalid DNS packet");
return {}; return {};
@ -43,12 +43,12 @@ ErrorOr<void> DNSServer::handle_client()
LookupServer& lookup_server = LookupServer::the(); LookupServer& lookup_server = LookupServer::the();
DNSPacket response; Packet response;
response.set_is_response(); response.set_is_response();
response.set_id(request.id()); response.set_id(request.id());
for (auto& question : request.questions()) { for (auto& question : request.questions()) {
if (question.class_code() != DNSRecordClass::IN) if (question.class_code() != RecordClass::IN)
continue; continue;
response.add_question(question); response.add_question(question);
auto answers = TRY(lookup_server.lookup(question.name(), question.record_type())); auto answers = TRY(lookup_server.lookup(question.name(), question.record_type()));
@ -58,9 +58,9 @@ ErrorOr<void> DNSServer::handle_client()
} }
if (response.answer_count() == 0) if (response.answer_count() == 0)
response.set_code(DNSPacket::Code::NXDOMAIN); response.set_code(Packet::Code::NXDOMAIN);
else else
response.set_code(DNSPacket::Code::NOERROR); response.set_code(Packet::Code::NOERROR);
buffer = response.to_byte_buffer(); buffer = response.to_byte_buffer();

60
Userland/Services/LookupServer/LookupServer.cpp
View file

@ -15,7 +15,7 @@
#include <LibCore/File.h> #include <LibCore/File.h>
#include <LibCore/LocalServer.h> #include <LibCore/LocalServer.h>
#include <LibCore/Stream.h> #include <LibCore/Stream.h>
#include <LibDNS/DNSPacket.h> #include <LibDNS/Packet.h>
#include <stdio.h> #include <stdio.h>
#include <time.h> #include <time.h>
#include <unistd.h> #include <unistd.h>
@ -78,8 +78,8 @@ LookupServer::LookupServer()
void LookupServer::load_etc_hosts() void LookupServer::load_etc_hosts()
{ {
m_etc_hosts.clear(); m_etc_hosts.clear();
auto add_answer = [this](DNSName const& name, DNSRecordType record_type, String data) { auto add_answer = [this](Name const& name, RecordType record_type, String data) {
m_etc_hosts.ensure(name).empend(name, record_type, DNSRecordClass::IN, s_static_ttl, move(data), false); m_etc_hosts.ensure(name).empend(name, record_type, RecordClass::IN, s_static_ttl, move(data), false);
}; };
auto file = Core::File::construct("/etc/hosts"); auto file = Core::File::construct("/etc/hosts");
@ -114,13 +114,13 @@ void LookupServer::load_etc_hosts()
auto raw_addr = maybe_address->to_in_addr_t(); auto raw_addr = maybe_address->to_in_addr_t();
DNSName name { fields[1] }; Name name { fields[1] };
add_answer(name, DNSRecordType::A, String { (char const*)&raw_addr, sizeof(raw_addr) }); add_answer(name, RecordType::A, String { (char const*)&raw_addr, sizeof(raw_addr) });
StringBuilder builder; StringBuilder builder;
builder.append(maybe_address->to_string_reversed()); builder.append(maybe_address->to_string_reversed());
builder.append(".in-addr.arpa"); builder.append(".in-addr.arpa");
add_answer(builder.to_string(), DNSRecordType::PTR, name.as_string()); add_answer(builder.to_string(), RecordType::PTR, name.as_string());
} }
} }
@ -131,13 +131,13 @@ static String get_hostname()
return buffer; return buffer;
} }
ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, DNSRecordType record_type) ErrorOr<Vector<Answer>> LookupServer::lookup(Name const& name, RecordType record_type)
{ {
dbgln_if(LOOKUPSERVER_DEBUG, "Got request for '{}'", name.as_string()); dbgln_if(LOOKUPSERVER_DEBUG, "Got request for '{}'", name.as_string());
Vector<DNSAnswer> answers; Vector<Answer> answers;
auto add_answer = [&](DNSAnswer const& answer) { auto add_answer = [&](Answer const& answer) {
DNSAnswer answer_with_original_case { Answer answer_with_original_case {
name, name,
answer.type(), answer.type(),
answer.class_code(), answer.class_code(),
@ -160,10 +160,10 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, DNSRecordTy
// Second, try the hostname. // Second, try the hostname.
// NOTE: We don't cache the hostname since it could change during runtime. // NOTE: We don't cache the hostname since it could change during runtime.
if (record_type == DNSRecordType::A && get_hostname() == name) { if (record_type == RecordType::A && get_hostname() == name) {
IPv4Address address = { 127, 0, 0, 1 }; IPv4Address address = { 127, 0, 0, 1 };
auto raw_address = address.to_in_addr_t(); auto raw_address = address.to_in_addr_t();
DNSAnswer answer { name, DNSRecordType::A, DNSRecordClass::IN, s_static_ttl, String { (char const*)&raw_address, sizeof(raw_address) }, false }; Answer answer { name, RecordType::A, RecordClass::IN, s_static_ttl, String { (char const*)&raw_address, sizeof(raw_address) }, false };
answers.append(move(answer)); answers.append(move(answer));
return answers; return answers;
} }
@ -194,7 +194,7 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, DNSRecordTy
dbgln_if(LOOKUPSERVER_DEBUG, "Doing lookup using nameserver '{}'", nameserver); dbgln_if(LOOKUPSERVER_DEBUG, "Doing lookup using nameserver '{}'", nameserver);
bool did_get_response = false; bool did_get_response = false;
int retries = 3; int retries = 3;
Vector<DNSAnswer> upstream_answers; Vector<Answer> upstream_answers;
do { do {
upstream_answers = TRY(lookup(name, nameserver, did_get_response, record_type)); upstream_answers = TRY(lookup(name, nameserver, did_get_response, record_type));
if (did_get_response) if (did_get_response)
@ -215,21 +215,21 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, DNSRecordTy
// Sixth, fail. // Sixth, fail.
if (answers.is_empty()) { if (answers.is_empty()) {
dbgln("Tried all nameservers but never got a response :("); dbgln("Tried all nameservers but never got a response :(");
return Vector<DNSAnswer> {}; return Vector<Answer> {};
} }
return answers; return answers;
} }
ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, String const& nameserver, bool& did_get_response, DNSRecordType record_type, ShouldRandomizeCase should_randomize_case) ErrorOr<Vector<Answer>> LookupServer::lookup(Name const& name, String const& nameserver, bool& did_get_response, RecordType record_type, ShouldRandomizeCase should_randomize_case)
{ {
DNSPacket request; Packet request;
request.set_is_query(); request.set_is_query();
request.set_id(get_random_uniform(UINT16_MAX)); request.set_id(get_random_uniform(UINT16_MAX));
DNSName name_in_question = name; Name name_in_question = name;
if (should_randomize_case == ShouldRandomizeCase::Yes) if (should_randomize_case == ShouldRandomizeCase::Yes)
name_in_question.randomize_case(); name_in_question.randomize_case();
request.add_question({ name_in_question, record_type, DNSRecordClass::IN, false }); request.add_question({ name_in_question, record_type, RecordClass::IN, false });
auto buffer = request.to_byte_buffer(); auto buffer = request.to_byte_buffer();
@ -241,32 +241,32 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, String cons
u8 response_buffer[4096]; u8 response_buffer[4096];
int nrecv = TRY(udp_socket->read({ response_buffer, sizeof(response_buffer) })); int nrecv = TRY(udp_socket->read({ response_buffer, sizeof(response_buffer) }));
if (udp_socket->is_eof()) if (udp_socket->is_eof())
return Vector<DNSAnswer> {}; return Vector<Answer> {};
did_get_response = true; did_get_response = true;
auto o_response = DNSPacket::from_raw_packet(response_buffer, nrecv); auto o_response = Packet::from_raw_packet(response_buffer, nrecv);
if (!o_response.has_value()) if (!o_response.has_value())
return Vector<DNSAnswer> {}; return Vector<Answer> {};
auto& response = o_response.value(); auto& response = o_response.value();
if (response.id() != request.id()) { if (response.id() != request.id()) {
dbgln("LookupServer: ID mismatch ({} vs {}) :(", response.id(), request.id()); dbgln("LookupServer: ID mismatch ({} vs {}) :(", response.id(), request.id());
return Vector<DNSAnswer> {}; return Vector<Answer> {};
} }
if (response.code() == DNSPacket::Code::REFUSED) { if (response.code() == Packet::Code::REFUSED) {
if (should_randomize_case == ShouldRandomizeCase::Yes) { if (should_randomize_case == ShouldRandomizeCase::Yes) {
// Retry with 0x20 case randomization turned off. // Retry with 0x20 case randomization turned off.
return lookup(name, nameserver, did_get_response, record_type, ShouldRandomizeCase::No); return lookup(name, nameserver, did_get_response, record_type, ShouldRandomizeCase::No);
} }
return Vector<DNSAnswer> {}; return Vector<Answer> {};
} }
if (response.question_count() != request.question_count()) { if (response.question_count() != request.question_count()) {
dbgln("LookupServer: Question count ({} vs {}) :(", response.question_count(), request.question_count()); dbgln("LookupServer: Question count ({} vs {}) :(", response.question_count(), request.question_count());
return Vector<DNSAnswer> {}; return Vector<Answer> {};
} }
// Verify the questions in our request and in their response match, ignoring case. // Verify the questions in our request and in their response match, ignoring case.
@ -280,16 +280,16 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, String cons
dbgln("Request and response questions do not match"); dbgln("Request and response questions do not match");
dbgln(" Request: name=_{}_, type={}, class={}", request_question.name().as_string(), response_question.record_type(), response_question.class_code()); dbgln(" Request: name=_{}_, type={}, class={}", request_question.name().as_string(), response_question.record_type(), response_question.class_code());
dbgln(" Response: name=_{}_, type={}, class={}", response_question.name().as_string(), response_question.record_type(), response_question.class_code()); dbgln(" Response: name=_{}_, type={}, class={}", response_question.name().as_string(), response_question.record_type(), response_question.class_code());
return Vector<DNSAnswer> {}; return Vector<Answer> {};
} }
} }
if (response.answer_count() < 1) { if (response.answer_count() < 1) {
dbgln("LookupServer: No answers :("); dbgln("LookupServer: No answers :(");
return Vector<DNSAnswer> {}; return Vector<Answer> {};
} }
Vector<DNSAnswer, 8> answers; Vector<Answer, 8> answers;
for (auto& answer : response.answers()) { for (auto& answer : response.answers()) {
put_in_cache(answer); put_in_cache(answer);
if (answer.type() != record_type) if (answer.type() != record_type)
@ -300,7 +300,7 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, String cons
return answers; return answers;
} }
void LookupServer::put_in_cache(DNSAnswer const& answer) void LookupServer::put_in_cache(Answer const& answer)
{ {
if (answer.has_expired()) if (answer.has_expired())
return; return;
@ -317,7 +317,7 @@ void LookupServer::put_in_cache(DNSAnswer const& answer)
if (answer.mdns_cache_flush()) { if (answer.mdns_cache_flush()) {
auto now = time(nullptr); auto now = time(nullptr);
it->value.remove_all_matching([&](DNSAnswer const& other_answer) { it->value.remove_all_matching([&](Answer const& other_answer) {
if (other_answer.type() != answer.type() || other_answer.class_code() != answer.class_code()) if (other_answer.type() != answer.type() || other_answer.class_code() != answer.class_code())
return false; return false;

14
Userland/Services/LookupServer/LookupServer.h
View file

@ -11,8 +11,8 @@
#include "MulticastDNS.h" #include "MulticastDNS.h"
#include <LibCore/FileWatcher.h> #include <LibCore/FileWatcher.h>
#include <LibCore/Object.h> #include <LibCore/Object.h>
#include <LibDNS/DNSName.h> #include <LibDNS/Name.h>
#include <LibDNS/DNSPacket.h> #include <LibDNS/Packet.h>
#include <LibIPC/MultiServer.h> #include <LibIPC/MultiServer.h>
namespace LookupServer { namespace LookupServer {
@ -24,23 +24,23 @@ class LookupServer final : public Core::Object {
public: public:
static LookupServer& the(); static LookupServer& the();
ErrorOr<Vector<DNSAnswer>> lookup(DNSName const& name, DNSRecordType record_type); ErrorOr<Vector<Answer>> lookup(Name const& name, RecordType record_type);
private: private:
LookupServer(); LookupServer();
void load_etc_hosts(); void load_etc_hosts();
void put_in_cache(DNSAnswer const&); void put_in_cache(Answer const&);
ErrorOr<Vector<DNSAnswer>> lookup(DNSName const& hostname, String const& nameserver, bool& did_get_response, DNSRecordType record_type, ShouldRandomizeCase = ShouldRandomizeCase::Yes); ErrorOr<Vector<Answer>> lookup(Name const& hostname, String const& nameserver, bool& did_get_response, RecordType record_type, ShouldRandomizeCase = ShouldRandomizeCase::Yes);
OwnPtr<IPC::MultiServer<ConnectionFromClient>> m_server; OwnPtr<IPC::MultiServer<ConnectionFromClient>> m_server;
RefPtr<DNSServer> m_dns_server; RefPtr<DNSServer> m_dns_server;
RefPtr<MulticastDNS> m_mdns; RefPtr<MulticastDNS> m_mdns;
Vector<String> m_nameservers; Vector<String> m_nameservers;
RefPtr<Core::FileWatcher> m_file_watcher; RefPtr<Core::FileWatcher> m_file_watcher;
HashMap<DNSName, Vector<DNSAnswer>, DNSName::Traits> m_etc_hosts; HashMap<Name, Vector<Answer>, Name::Traits> m_etc_hosts;
HashMap<DNSName, Vector<DNSAnswer>, DNSName::Traits> m_lookup_cache; HashMap<Name, Vector<Answer>, Name::Traits> m_lookup_cache;
}; };
} }

26
Userland/Services/LookupServer/MulticastDNS.cpp
View file

@ -52,7 +52,7 @@ MulticastDNS::MulticastDNS(Object* parent)
void MulticastDNS::handle_packet() void MulticastDNS::handle_packet()
{ {
auto buffer = receive(1024); auto buffer = receive(1024);
auto optional_packet = DNSPacket::from_raw_packet(buffer.data(), buffer.size()); auto optional_packet = Packet::from_raw_packet(buffer.data(), buffer.size());
if (!optional_packet.has_value()) { if (!optional_packet.has_value()) {
dbgln("Got an invalid mDNS packet"); dbgln("Got an invalid mDNS packet");
return; return;
@ -63,7 +63,7 @@ void MulticastDNS::handle_packet()
handle_query(packet); handle_query(packet);
} }
void MulticastDNS::handle_query(DNSPacket const& packet) void MulticastDNS::handle_query(Packet const& packet)
{ {
bool should_reply = false; bool should_reply = false;
@ -79,19 +79,19 @@ void MulticastDNS::handle_query(DNSPacket const& packet)
void MulticastDNS::announce() void MulticastDNS::announce()
{ {
DNSPacket response; Packet response;
response.set_is_response(); response.set_is_response();
response.set_code(DNSPacket::Code::NOERROR); response.set_code(Packet::Code::NOERROR);
response.set_authoritative_answer(true); response.set_authoritative_answer(true);
response.set_recursion_desired(false); response.set_recursion_desired(false);
response.set_recursion_available(false); response.set_recursion_available(false);
for (auto& address : local_addresses()) { for (auto& address : local_addresses()) {
auto raw_addr = address.to_in_addr_t(); auto raw_addr = address.to_in_addr_t();
DNSAnswer answer { Answer answer {
m_hostname, m_hostname,
DNSRecordType::A, RecordType::A,
DNSRecordClass::IN, RecordClass::IN,
120, 120,
String { (char const*)&raw_addr, sizeof(raw_addr) }, String { (char const*)&raw_addr, sizeof(raw_addr) },
true, true,
@ -103,7 +103,7 @@ void MulticastDNS::announce()
perror("Failed to emit response packet"); perror("Failed to emit response packet");
} }
ErrorOr<size_t> MulticastDNS::emit_packet(DNSPacket const& packet, sockaddr_in const* destination) ErrorOr<size_t> MulticastDNS::emit_packet(Packet const& packet, sockaddr_in const* destination)
{ {
auto buffer = packet.to_byte_buffer(); auto buffer = packet.to_byte_buffer();
if (!destination) if (!destination)
@ -141,19 +141,19 @@ Vector<IPv4Address> MulticastDNS::local_addresses() const
return addresses; return addresses;
} }
Vector<DNSAnswer> MulticastDNS::lookup(DNSName const& name, DNSRecordType record_type) Vector<Answer> MulticastDNS::lookup(Name const& name, RecordType record_type)
{ {
DNSPacket request; Packet request;
request.set_is_query(); request.set_is_query();
request.set_recursion_desired(false); request.set_recursion_desired(false);
request.add_question({ name, record_type, DNSRecordClass::IN, false }); request.add_question({ name, record_type, RecordClass::IN, false });
if (emit_packet(request).is_error()) { if (emit_packet(request).is_error()) {
perror("failed to emit request packet"); perror("failed to emit request packet");
return {}; return {};
} }
Vector<DNSAnswer> answers; Vector<Answer> answers;
// FIXME: It would be better not to block // FIXME: It would be better not to block
// the main loop while we wait for a response. // the main loop while we wait for a response.
@ -170,7 +170,7 @@ Vector<DNSAnswer> MulticastDNS::lookup(DNSName const& name, DNSRecordType record
auto buffer = receive(1024); auto buffer = receive(1024);
if (buffer.is_empty()) if (buffer.is_empty())
return {}; return {};
auto optional_packet = DNSPacket::from_raw_packet(buffer.data(), buffer.size()); auto optional_packet = Packet::from_raw_packet(buffer.data(), buffer.size());
if (!optional_packet.has_value()) { if (!optional_packet.has_value()) {
dbgln("Got an invalid mDNS packet"); dbgln("Got an invalid mDNS packet");
continue; continue;

14
Userland/Services/LookupServer/MulticastDNS.h
View file

@ -8,9 +8,9 @@
#include <AK/IPv4Address.h> #include <AK/IPv4Address.h>
#include <LibCore/UDPServer.h> #include <LibCore/UDPServer.h>
#include <LibDNS/DNSAnswer.h> #include <LibDNS/Answer.h>
#include <LibDNS/DNSName.h> #include <LibDNS/Name.h>
#include <LibDNS/DNSPacket.h> #include <LibDNS/Packet.h>
#include <netinet/in.h> #include <netinet/in.h>
namespace LookupServer { namespace LookupServer {
@ -20,20 +20,20 @@ using namespace DNS;
class MulticastDNS : public Core::UDPServer { class MulticastDNS : public Core::UDPServer {
C_OBJECT(MulticastDNS) C_OBJECT(MulticastDNS)
public: public:
Vector<DNSAnswer> lookup(DNSName const&, DNSRecordType record_type); Vector<Answer> lookup(Name const&, RecordType record_type);
private: private:
explicit MulticastDNS(Object* parent = nullptr); explicit MulticastDNS(Object* parent = nullptr);
void announce(); void announce();
ErrorOr<size_t> emit_packet(DNSPacket const&, sockaddr_in const* destination = nullptr); ErrorOr<size_t> emit_packet(Packet const&, sockaddr_in const* destination = nullptr);
void handle_packet(); void handle_packet();
void handle_query(DNSPacket const&); void handle_query(Packet const&);
Vector<IPv4Address> local_addresses() const; Vector<IPv4Address> local_addresses() const;
DNSName m_hostname; Name m_hostname;
static constexpr sockaddr_in mdns_addr { static constexpr sockaddr_in mdns_addr {
AF_INET, AF_INET,