mirror of
https://github.com/RGBCube/serenity
synced 2025-07-29 01:37:44 +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:
Tom
Linus Groh
parent
a3a1fe833b
commit
49de4d5f33
17 changed files with 219 additions and 219 deletions
|
|
@ -7,7 +7,7 @@
|
|||
#include "ConnectionFromClient.h"
|
||||
#include "LookupServer.h"
|
||||
#include <AK/IPv4Address.h>
|
||||
#include <LibDNS/DNSPacket.h>
|
||||
#include <LibDNS/Packet.h>
|
||||
|
||||
namespace LookupServer {
|
||||
|
||||
|
|
@ -28,7 +28,7 @@ void ConnectionFromClient::die()
|
|||
|
||||
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()) {
|
||||
dbgln("LookupServer: Failed to lookup A record: {}", maybe_answers.error());
|
||||
return { 1, {} };
|
||||
|
|
@ -53,7 +53,7 @@ Messages::LookupServer::LookupAddressResponse ConnectionFromClient::lookup_addre
|
|||
ip_address[1],
|
||||
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()) {
|
||||
dbgln("LookupServer: Failed to lookup PTR record: {}", maybe_answers.error());
|
||||
return { 1, String() };
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
#include "DNSServer.h"
|
||||
#include "LookupServer.h"
|
||||
#include <AK/IPv4Address.h>
|
||||
#include <LibDNS/DNSPacket.h>
|
||||
#include <LibDNS/Packet.h>
|
||||
|
||||
namespace LookupServer {
|
||||
|
||||
|
|
@ -29,7 +29,7 @@ ErrorOr<void> DNSServer::handle_client()
|
|||
{
|
||||
sockaddr_in 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()) {
|
||||
dbgln("Got an invalid DNS packet");
|
||||
return {};
|
||||
|
|
@ -43,12 +43,12 @@ ErrorOr<void> DNSServer::handle_client()
|
|||
|
||||
LookupServer& lookup_server = LookupServer::the();
|
||||
|
||||
DNSPacket response;
|
||||
Packet response;
|
||||
response.set_is_response();
|
||||
response.set_id(request.id());
|
||||
|
||||
for (auto& question : request.questions()) {
|
||||
if (question.class_code() != DNSRecordClass::IN)
|
||||
if (question.class_code() != RecordClass::IN)
|
||||
continue;
|
||||
response.add_question(question);
|
||||
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)
|
||||
response.set_code(DNSPacket::Code::NXDOMAIN);
|
||||
response.set_code(Packet::Code::NXDOMAIN);
|
||||
else
|
||||
response.set_code(DNSPacket::Code::NOERROR);
|
||||
response.set_code(Packet::Code::NOERROR);
|
||||
|
||||
buffer = response.to_byte_buffer();
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
#include <LibCore/File.h>
|
||||
#include <LibCore/LocalServer.h>
|
||||
#include <LibCore/Stream.h>
|
||||
#include <LibDNS/DNSPacket.h>
|
||||
#include <LibDNS/Packet.h>
|
||||
#include <stdio.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
|
@ -78,8 +78,8 @@ LookupServer::LookupServer()
|
|||
void LookupServer::load_etc_hosts()
|
||||
{
|
||||
m_etc_hosts.clear();
|
||||
auto add_answer = [this](DNSName const& name, DNSRecordType record_type, String data) {
|
||||
m_etc_hosts.ensure(name).empend(name, record_type, DNSRecordClass::IN, s_static_ttl, move(data), false);
|
||||
auto add_answer = [this](Name const& name, RecordType record_type, String data) {
|
||||
m_etc_hosts.ensure(name).empend(name, record_type, RecordClass::IN, s_static_ttl, move(data), false);
|
||||
};
|
||||
|
||||
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();
|
||||
|
||||
DNSName name { fields[1] };
|
||||
add_answer(name, DNSRecordType::A, String { (char const*)&raw_addr, sizeof(raw_addr) });
|
||||
Name name { fields[1] };
|
||||
add_answer(name, RecordType::A, String { (char const*)&raw_addr, sizeof(raw_addr) });
|
||||
|
||||
StringBuilder builder;
|
||||
builder.append(maybe_address->to_string_reversed());
|
||||
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;
|
||||
}
|
||||
|
||||
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());
|
||||
|
||||
Vector<DNSAnswer> answers;
|
||||
auto add_answer = [&](DNSAnswer const& answer) {
|
||||
DNSAnswer answer_with_original_case {
|
||||
Vector<Answer> answers;
|
||||
auto add_answer = [&](Answer const& answer) {
|
||||
Answer answer_with_original_case {
|
||||
name,
|
||||
answer.type(),
|
||||
answer.class_code(),
|
||||
|
|
@ -160,10 +160,10 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, DNSRecordTy
|
|||
|
||||
// Second, try the hostname.
|
||||
// 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 };
|
||||
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));
|
||||
return answers;
|
||||
}
|
||||
|
|
@ -194,7 +194,7 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, DNSRecordTy
|
|||
dbgln_if(LOOKUPSERVER_DEBUG, "Doing lookup using nameserver '{}'", nameserver);
|
||||
bool did_get_response = false;
|
||||
int retries = 3;
|
||||
Vector<DNSAnswer> upstream_answers;
|
||||
Vector<Answer> upstream_answers;
|
||||
do {
|
||||
upstream_answers = TRY(lookup(name, nameserver, did_get_response, record_type));
|
||||
if (did_get_response)
|
||||
|
|
@ -215,21 +215,21 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, DNSRecordTy
|
|||
// Sixth, fail.
|
||||
if (answers.is_empty()) {
|
||||
dbgln("Tried all nameservers but never got a response :(");
|
||||
return Vector<DNSAnswer> {};
|
||||
return Vector<Answer> {};
|
||||
}
|
||||
|
||||
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_id(get_random_uniform(UINT16_MAX));
|
||||
DNSName name_in_question = name;
|
||||
Name name_in_question = name;
|
||||
if (should_randomize_case == ShouldRandomizeCase::Yes)
|
||||
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();
|
||||
|
||||
|
|
@ -241,32 +241,32 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, String cons
|
|||
u8 response_buffer[4096];
|
||||
int nrecv = TRY(udp_socket->read({ response_buffer, sizeof(response_buffer) }));
|
||||
if (udp_socket->is_eof())
|
||||
return Vector<DNSAnswer> {};
|
||||
return Vector<Answer> {};
|
||||
|
||||
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())
|
||||
return Vector<DNSAnswer> {};
|
||||
return Vector<Answer> {};
|
||||
|
||||
auto& response = o_response.value();
|
||||
|
||||
if (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) {
|
||||
// Retry with 0x20 case randomization turned off.
|
||||
return lookup(name, nameserver, did_get_response, record_type, ShouldRandomizeCase::No);
|
||||
}
|
||||
return Vector<DNSAnswer> {};
|
||||
return Vector<Answer> {};
|
||||
}
|
||||
|
||||
if (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.
|
||||
|
|
@ -280,16 +280,16 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, String cons
|
|||
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(" 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) {
|
||||
dbgln("LookupServer: No answers :(");
|
||||
return Vector<DNSAnswer> {};
|
||||
return Vector<Answer> {};
|
||||
}
|
||||
|
||||
Vector<DNSAnswer, 8> answers;
|
||||
Vector<Answer, 8> answers;
|
||||
for (auto& answer : response.answers()) {
|
||||
put_in_cache(answer);
|
||||
if (answer.type() != record_type)
|
||||
|
|
@ -300,7 +300,7 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, String cons
|
|||
return answers;
|
||||
}
|
||||
|
||||
void LookupServer::put_in_cache(DNSAnswer const& answer)
|
||||
void LookupServer::put_in_cache(Answer const& answer)
|
||||
{
|
||||
if (answer.has_expired())
|
||||
return;
|
||||
|
|
@ -317,7 +317,7 @@ void LookupServer::put_in_cache(DNSAnswer const& answer)
|
|||
if (answer.mdns_cache_flush()) {
|
||||
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())
|
||||
return false;
|
||||
|
||||
|
|
|
|||
|
|
@ -11,8 +11,8 @@
|
|||
#include "MulticastDNS.h"
|
||||
#include <LibCore/FileWatcher.h>
|
||||
#include <LibCore/Object.h>
|
||||
#include <LibDNS/DNSName.h>
|
||||
#include <LibDNS/DNSPacket.h>
|
||||
#include <LibDNS/Name.h>
|
||||
#include <LibDNS/Packet.h>
|
||||
#include <LibIPC/MultiServer.h>
|
||||
|
||||
namespace LookupServer {
|
||||
|
|
@ -24,23 +24,23 @@ class LookupServer final : public Core::Object {
|
|||
|
||||
public:
|
||||
static LookupServer& the();
|
||||
ErrorOr<Vector<DNSAnswer>> lookup(DNSName const& name, DNSRecordType record_type);
|
||||
ErrorOr<Vector<Answer>> lookup(Name const& name, RecordType record_type);
|
||||
|
||||
private:
|
||||
LookupServer();
|
||||
|
||||
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;
|
||||
RefPtr<DNSServer> m_dns_server;
|
||||
RefPtr<MulticastDNS> m_mdns;
|
||||
Vector<String> m_nameservers;
|
||||
RefPtr<Core::FileWatcher> m_file_watcher;
|
||||
HashMap<DNSName, Vector<DNSAnswer>, DNSName::Traits> m_etc_hosts;
|
||||
HashMap<DNSName, Vector<DNSAnswer>, DNSName::Traits> m_lookup_cache;
|
||||
HashMap<Name, Vector<Answer>, Name::Traits> m_etc_hosts;
|
||||
HashMap<Name, Vector<Answer>, Name::Traits> m_lookup_cache;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ MulticastDNS::MulticastDNS(Object* parent)
|
|||
void MulticastDNS::handle_packet()
|
||||
{
|
||||
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()) {
|
||||
dbgln("Got an invalid mDNS packet");
|
||||
return;
|
||||
|
|
@ -63,7 +63,7 @@ void MulticastDNS::handle_packet()
|
|||
handle_query(packet);
|
||||
}
|
||||
|
||||
void MulticastDNS::handle_query(DNSPacket const& packet)
|
||||
void MulticastDNS::handle_query(Packet const& packet)
|
||||
{
|
||||
bool should_reply = false;
|
||||
|
||||
|
|
@ -79,19 +79,19 @@ void MulticastDNS::handle_query(DNSPacket const& packet)
|
|||
|
||||
void MulticastDNS::announce()
|
||||
{
|
||||
DNSPacket response;
|
||||
Packet response;
|
||||
response.set_is_response();
|
||||
response.set_code(DNSPacket::Code::NOERROR);
|
||||
response.set_code(Packet::Code::NOERROR);
|
||||
response.set_authoritative_answer(true);
|
||||
response.set_recursion_desired(false);
|
||||
response.set_recursion_available(false);
|
||||
|
||||
for (auto& address : local_addresses()) {
|
||||
auto raw_addr = address.to_in_addr_t();
|
||||
DNSAnswer answer {
|
||||
Answer answer {
|
||||
m_hostname,
|
||||
DNSRecordType::A,
|
||||
DNSRecordClass::IN,
|
||||
RecordType::A,
|
||||
RecordClass::IN,
|
||||
120,
|
||||
String { (char const*)&raw_addr, sizeof(raw_addr) },
|
||||
true,
|
||||
|
|
@ -103,7 +103,7 @@ void MulticastDNS::announce()
|
|||
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();
|
||||
if (!destination)
|
||||
|
|
@ -141,19 +141,19 @@ Vector<IPv4Address> MulticastDNS::local_addresses() const
|
|||
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_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()) {
|
||||
perror("failed to emit request packet");
|
||||
return {};
|
||||
}
|
||||
|
||||
Vector<DNSAnswer> answers;
|
||||
Vector<Answer> answers;
|
||||
|
||||
// FIXME: It would be better not to block
|
||||
// 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);
|
||||
if (buffer.is_empty())
|
||||
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()) {
|
||||
dbgln("Got an invalid mDNS packet");
|
||||
continue;
|
||||
|
|
|
|||
|
|
@ -8,9 +8,9 @@
|
|||
|
||||
#include <AK/IPv4Address.h>
|
||||
#include <LibCore/UDPServer.h>
|
||||
#include <LibDNS/DNSAnswer.h>
|
||||
#include <LibDNS/DNSName.h>
|
||||
#include <LibDNS/DNSPacket.h>
|
||||
#include <LibDNS/Answer.h>
|
||||
#include <LibDNS/Name.h>
|
||||
#include <LibDNS/Packet.h>
|
||||
#include <netinet/in.h>
|
||||
|
||||
namespace LookupServer {
|
||||
|
|
@ -20,20 +20,20 @@ using namespace DNS;
|
|||
class MulticastDNS : public Core::UDPServer {
|
||||
C_OBJECT(MulticastDNS)
|
||||
public:
|
||||
Vector<DNSAnswer> lookup(DNSName const&, DNSRecordType record_type);
|
||||
Vector<Answer> lookup(Name const&, RecordType record_type);
|
||||
|
||||
private:
|
||||
explicit MulticastDNS(Object* parent = nullptr);
|
||||
|
||||
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_query(DNSPacket const&);
|
||||
void handle_query(Packet const&);
|
||||
|
||||
Vector<IPv4Address> local_addresses() const;
|
||||
|
||||
DNSName m_hostname;
|
||||
Name m_hostname;
|
||||
|
||||
static constexpr sockaddr_in mdns_addr {
|
||||
AF_INET,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue