RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-28 21:07:35 +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
*/
#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 {};
}

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

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

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

@ -1,7 +1,7 @@
set(SOURCES
DNSAnswer.cpp
DNSName.cpp
DNSPacket.cpp
Answer.cpp
Name.cpp
Packet.cpp
)
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
*/
#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
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
*/
#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();
}

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

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

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

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

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

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

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

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