mirror of
https://github.com/RGBCube/serenity
synced 2025-10-31 13:22:43 +00:00
ae64b68717
This also removes a few cases where the respective header wasn't actually required to be included.
128 lines
3.6 KiB
C++
128 lines
3.6 KiB
C++
/*
|
|
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "Answer.h"
|
|
#include <LibIPC/Decoder.h>
|
|
#include <LibIPC/Encoder.h>
|
|
#include <time.h>
|
|
|
|
namespace DNS {
|
|
|
|
Answer::Answer(Name const& name, RecordType type, RecordClass class_code, u32 ttl, DeprecatedString const& record_data, bool mdns_cache_flush)
|
|
: m_name(name)
|
|
, m_type(type)
|
|
, m_class_code(class_code)
|
|
, m_ttl(ttl)
|
|
, m_record_data(record_data)
|
|
, m_mdns_cache_flush(mdns_cache_flush)
|
|
{
|
|
time(&m_received_time);
|
|
}
|
|
|
|
bool Answer::has_expired() const
|
|
{
|
|
return time(nullptr) >= m_received_time + m_ttl;
|
|
}
|
|
|
|
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()));
|
|
hash = pair_int_hash(hash, record_data().hash());
|
|
hash = pair_int_hash(hash, (u32)mdns_cache_flush());
|
|
return hash;
|
|
}
|
|
|
|
bool Answer::operator==(Answer const& other) const
|
|
{
|
|
if (&other == this)
|
|
return true;
|
|
if (!Name::Traits::equals(name(), other.name()))
|
|
return false;
|
|
if (type() != other.type())
|
|
return false;
|
|
if (class_code() != other.class_code())
|
|
return false;
|
|
if (ttl() != other.ttl())
|
|
return false;
|
|
if (record_data() != other.record_data())
|
|
return false;
|
|
if (mdns_cache_flush() != other.mdns_cache_flush())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
ErrorOr<void> AK::Formatter<DNS::RecordType>::format(AK::FormatBuilder& builder, DNS::RecordType value)
|
|
{
|
|
switch (value) {
|
|
case DNS::RecordType::A:
|
|
return builder.put_string("A"sv);
|
|
case DNS::RecordType::NS:
|
|
return builder.put_string("NS"sv);
|
|
case DNS::RecordType::CNAME:
|
|
return builder.put_string("CNAME"sv);
|
|
case DNS::RecordType::SOA:
|
|
return builder.put_string("SOA"sv);
|
|
case DNS::RecordType::PTR:
|
|
return builder.put_string("PTR"sv);
|
|
case DNS::RecordType::MX:
|
|
return builder.put_string("MX"sv);
|
|
case DNS::RecordType::TXT:
|
|
return builder.put_string("TXT"sv);
|
|
case DNS::RecordType::AAAA:
|
|
return builder.put_string("AAAA"sv);
|
|
case DNS::RecordType::SRV:
|
|
return builder.put_string("SRV"sv);
|
|
}
|
|
|
|
TRY(builder.put_string("DNS record type "sv));
|
|
TRY(builder.put_u64((u16)value));
|
|
return {};
|
|
}
|
|
|
|
ErrorOr<void> AK::Formatter<DNS::RecordClass>::format(AK::FormatBuilder& builder, DNS::RecordClass value)
|
|
{
|
|
switch (value) {
|
|
case DNS::RecordClass::IN:
|
|
return builder.put_string("IN"sv);
|
|
}
|
|
|
|
TRY(builder.put_string("DNS record class "sv));
|
|
TRY(builder.put_u64((u16)value));
|
|
return {};
|
|
}
|
|
|
|
namespace IPC {
|
|
|
|
template<>
|
|
ErrorOr<void> encode(Encoder& encoder, DNS::Answer const& answer)
|
|
{
|
|
TRY(encoder.encode(answer.name().as_string()));
|
|
TRY(encoder.encode(static_cast<u16>(answer.type())));
|
|
TRY(encoder.encode(static_cast<u16>(answer.class_code())));
|
|
TRY(encoder.encode(answer.ttl()));
|
|
TRY(encoder.encode(answer.record_data()));
|
|
TRY(encoder.encode(answer.mdns_cache_flush()));
|
|
|
|
return {};
|
|
}
|
|
|
|
template<>
|
|
ErrorOr<DNS::Answer> decode(Decoder& decoder)
|
|
{
|
|
auto name = TRY(decoder.decode<DeprecatedString>());
|
|
auto record_type = TRY(decoder.decode<DNS::RecordType>());
|
|
auto class_code = TRY(decoder.decode<DNS::RecordClass>());
|
|
auto ttl = TRY(decoder.decode<u32>());
|
|
auto record_data = TRY(decoder.decode<DeprecatedString>());
|
|
auto cache_flush = TRY(decoder.decode<bool>());
|
|
|
|
return DNS::Answer { name, record_type, class_code, ttl, record_data, cache_flush };
|
|
}
|
|
|
|
}
|