RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 07:07:45 +00:00
Code Issues Activity Actions

LookupServer: Replace dbg()/dbgprintf() with dbgln()

Browse source
This commit is contained in:
Linus Groh 2020-10-25 14:46:04 +00:00 • committed by Andreas Kling
parent 956e9aa736
commit 75864b5a85
2 changed files with 20 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

18
Services/LookupServer/DNSResponse.cpp
View file

@ -57,16 +57,16 @@ static_assert(sizeof(DNSRecordWithoutName) == 10);
Optional<DNSResponse> DNSResponse::from_raw_response(const u8* raw_data, size_t raw_size)
{
if (raw_size < sizeof(DNSPacket)) {
dbg() << "DNS response not large enough (" << raw_size << " out of " << sizeof(DNSPacket) << ") to be a DNS packet.";
dbgln("DNS response not large enough ({} out of {}) to be a DNS packet.", raw_size, sizeof(DNSPacket));
return {};
}
auto& response_header = *(const DNSPacket*)(raw_data);
dbgprintf("Got response (ID: %u)\n", response_header.id());
dbgprintf(" Question count: %u\n", response_header.question_count());
dbgprintf(" Answer count: %u\n", response_header.answer_count());
dbgprintf(" Authority count: %u\n", response_header.authority_count());
dbgprintf("Additional count: %u\n", response_header.additional_count());
dbgln("Got response (ID: {})", response_header.id());
dbgln(" Question count: {}", response_header.question_count());
dbgln(" Answer count: {}", response_header.answer_count());
dbgln(" Authority count: {}", response_header.authority_count());
dbgln("Additional count: {}", response_header.additional_count());
DNSResponse response;
response.m_id = response_header.id();
@ -87,7 +87,7 @@ Optional<DNSResponse> DNSResponse::from_raw_response(const u8* raw_data, size_t
response.m_questions.empend(name, record_and_class.record_type, record_and_class.class_code);
auto& question = response.m_questions.last();
offset += 4;
dbg() << "Question #" << i << ": _" << question.name() << "_ type: " << question.record_type() << ", class: " << question.class_code();
dbgln("Question #{}: name=_{}_, type={}, class={}", i, question.name(), question.record_type(), question.class_code());
}
for (u16 i = 0; i < response_header.answer_count(); ++i) {
@ -106,9 +106,9 @@ Optional<DNSResponse> DNSResponse::from_raw_response(const u8* raw_data, size_t
data = ipv4_address.to_string();
} else {
// FIXME: Parse some other record types perhaps?
dbg() << " data=(unimplemented record type " << record.type() << ")";
dbgln("data=(unimplemented record type {})", record.type());
}
dbg() << "Answer #" << i << ": name=_" << name << "_, type=" << record.type() << ", ttl=" << record.ttl() << ", length=" << record.data_length() << ", data=_" << data << "_";
dbgln("Answer #{}: name=_{}_, type={}, ttl={}, length={}, data=_{}_", i, name, record.type(), record.ttl(), record.data_length(), data);
response.m_answers.empend(name, record.type(), record.record_class(), record.ttl(), data);
offset += record.data_length();
}

23
Services/LookupServer/LookupServer.cpp
View file

@ -42,7 +42,7 @@
LookupServer::LookupServer()
{
auto config = Core::ConfigFile::get_for_system("LookupServer");
dbg() << "Using network config file at " << config->file_name();
dbgln("Using network config file at {}", config->file_name());
m_nameserver = config->read_entry("DNS", "Nameserver", "1.1.1.1");
load_etc_hosts();
@ -109,11 +109,11 @@ void LookupServer::service_client(RefPtr<Core::LocalSocket> socket)
char lookup_type = client_buffer[0];
if (lookup_type != 'L' && lookup_type != 'R') {
dbg() << "Invalid lookup_type " << lookup_type;
dbgln("Invalid lookup_type '{}'", lookup_type);
return;
}
auto hostname = String((const char*)client_buffer + 1, nrecv - 1, Chomp);
dbg() << "Got request for '" << hostname << "' (using IP " << m_nameserver << ")";
dbgln("Got request for '{}' (using IP {})", hostname, m_nameserver);
Vector<String> responses;
@ -160,10 +160,9 @@ Vector<String> LookupServer::lookup(const String& hostname, bool& did_timeout, u
if (cached_lookup.question.record_type() == record_type) {
Vector<String> responses;
for (auto& cached_answer : cached_lookup.answers) {
dbg() << "Cache hit: " << hostname << " -> " << cached_answer.record_data() << ", expired: " << cached_answer.has_expired();
if (!cached_answer.has_expired()) {
dbgln("Cache hit: {} -> {}, expired: {}", hostname, cached_answer.record_data(), cached_answer.has_expired());
if (!cached_answer.has_expired())
responses.append(cached_answer.record_data());
}
}
if (!responses.is_empty())
return responses;
@ -207,7 +206,7 @@ Vector<String> LookupServer::lookup(const String& hostname, bool& did_timeout, u
auto& response = o_response.value();
if (response.id() != request.id()) {
dbgprintf("LookupServer: ID mismatch (%u vs %u) :(\n", response.id(), request.id());
dbgln("LookupServer: ID mismatch ({} vs {}) :(", response.id(), request.id());
return {};
}
@ -220,7 +219,7 @@ Vector<String> LookupServer::lookup(const String& hostname, bool& did_timeout, u
}
if (response.question_count() != request.question_count()) {
dbgprintf("LookupServer: Question count (%u vs %u) :(\n", response.question_count(), request.question_count());
dbgln("LookupServer: Question count ({} vs {}) :(", response.question_count(), request.question_count());
return {};
}
@ -228,15 +227,15 @@ Vector<String> LookupServer::lookup(const String& hostname, bool& did_timeout, u
auto& request_question = request.questions()[i];
auto& response_question = response.questions()[i];
if (request_question != response_question) {
dbg() << "Request and response questions do not match";
dbg() << " Request: {_" << request_question.name() << "_, " << request_question.record_type() << ", " << request_question.class_code() << "}";
dbg() << " Response: {_" << response_question.name() << "_, " << response_question.record_type() << ", " << response_question.class_code() << "}";
dbgln("Request and response questions do not match");
dbgln(" Request: name=_{}_, type={}, class={}", request_question.name(), response_question.record_type(), response_question.class_code());
dbgln(" Response: name=_{}_, type={}, class={}", response_question.name(), response_question.record_type(), response_question.class_code());
return {};
}
}
if (response.answer_count() < 1) {
dbgprintf("LookupServer: Not enough answers (%u) :(\n", response.answer_count());
dbgln("LookupServer: Not enough answers ({}) :(", response.answer_count());
return {};
}