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

Everywhere: Run clang-format

Browse source
This commit is contained in:
Idan Horowitz 2022-04-01 20:58:27 +03:00 • committed by Linus Groh
parent 0376c127f6
commit 086969277e
1665 changed files with 8479 additions and 8479 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -44,7 +44,7 @@ Messages::LookupServer::LookupAddressResponse ConnectionFromClient::lookup_addre
{
if (address.length() != 4)
return { 1, String() };
IPv4Address ip_address { (const u8*)address.characters() };
IPv4Address ip_address { (u8 const*)address.characters() };
auto name = String::formatted("{}.{}.{}.{}.in-addr.arpa",
ip_address[3],
ip_address[2],

2
Userland/Services/LookupServer/DNSAnswer.cpp
View file

@ -10,7 +10,7 @@
namespace LookupServer {
DNSAnswer::DNSAnswer(const DNSName& name, DNSRecordType type, DNSRecordClass class_code, u32 ttl, const String& record_data, bool mdns_cache_flush)
DNSAnswer::DNSAnswer(DNSName const& name, DNSRecordType type, DNSRecordClass class_code, u32 ttl, String const& record_data, bool mdns_cache_flush)
: m_name(name)
, m_type(type)
, m_class_code(class_code)

6
Userland/Services/LookupServer/DNSAnswer.h
View file

@ -33,15 +33,15 @@ enum class DNSRecordClass : u16 {
class DNSAnswer {
public:
DNSAnswer(const DNSName& name, DNSRecordType type, DNSRecordClass class_code, u32 ttl, const String& record_data, bool mdns_cache_flush);
DNSAnswer(DNSName const& name, DNSRecordType type, DNSRecordClass class_code, u32 ttl, String const& record_data, bool mdns_cache_flush);
const DNSName& name() const { return m_name; }
DNSName const& name() const { return m_name; }
DNSRecordType type() const { return m_type; }
DNSRecordClass 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; }
const String& record_data() const { return m_record_data; }
String const& record_data() const { return m_record_data; }
bool mdns_cache_flush() const { return m_mdns_cache_flush; }
bool has_expired() const;

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

@ -12,7 +12,7 @@
namespace LookupServer {
DNSName::DNSName(const String& name)
DNSName::DNSName(String const& name)
{
if (name.ends_with('.'))
m_name = name.substring(0, name.length() - 1);
@ -20,7 +20,7 @@ DNSName::DNSName(const String& name)
m_name = name;
}
DNSName DNSName::parse(const u8* data, size_t& offset, size_t max_offset, size_t recursion_level)
DNSName DNSName::parse(u8 const* data, size_t& offset, size_t max_offset, size_t recursion_level)
{
if (recursion_level > 4)
return DNSName({});
@ -45,7 +45,7 @@ DNSName DNSName::parse(const u8* data, size_t& offset, size_t max_offset, size_t
// This is the length of a part.
if (offset + b >= max_offset)
return DNSName({});
builder.append((const char*)&data[offset], (size_t)b);
builder.append((char const*)&data[offset], (size_t)b);
builder.append('.');
offset += b;
}
@ -75,7 +75,7 @@ void DNSName::randomize_case()
m_name = builder.to_string();
}
OutputStream& operator<<(OutputStream& stream, const DNSName& name)
OutputStream& operator<<(OutputStream& stream, DNSName const& name)
{
auto parts = name.as_string().split_view('.');
for (auto& part : parts) {
@ -86,12 +86,12 @@ OutputStream& operator<<(OutputStream& stream, const DNSName& name)
return stream;
}
unsigned DNSName::Traits::hash(const DNSName& name)
unsigned DNSName::Traits::hash(DNSName const& name)
{
return CaseInsensitiveStringTraits::hash(name.as_string());
}
bool DNSName::Traits::equals(const DNSName& a, const DNSName& b)
bool DNSName::Traits::equals(DNSName const& a, DNSName const& b)
{
return CaseInsensitiveStringTraits::equals(a.as_string(), b.as_string());
}

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

@ -14,28 +14,28 @@ namespace LookupServer {
class DNSName {
public:
DNSName(const String&);
DNSName(String const&);
static DNSName parse(const u8* data, size_t& offset, size_t max_offset, size_t recursion_level = 0);
static DNSName parse(u8 const* data, size_t& offset, size_t max_offset, size_t recursion_level = 0);
size_t serialized_size() const;
const String& as_string() const { return m_name; }
String const& as_string() const { return m_name; }
void randomize_case();
bool operator==(const DNSName& other) const { return Traits::equals(*this, other); }
bool operator==(DNSName const& other) const { return Traits::equals(*this, other); }
class Traits : public AK::Traits<DNSName> {
public:
static unsigned hash(const DNSName& name);
static bool equals(const DNSName&, const DNSName&);
static unsigned hash(DNSName const& name);
static bool equals(DNSName const&, DNSName const&);
};
private:
String m_name;
};
OutputStream& operator<<(OutputStream& stream, const DNSName&);
OutputStream& operator<<(OutputStream& stream, DNSName const&);
}

14
Userland/Services/LookupServer/DNSPacket.cpp
View file

@ -16,14 +16,14 @@
namespace LookupServer {
void DNSPacket::add_question(const DNSQuestion& question)
void DNSPacket::add_question(DNSQuestion const& question)
{
m_questions.empend(question);
VERIFY(m_questions.size() <= UINT16_MAX);
}
void DNSPacket::add_answer(const DNSAnswer& answer)
void DNSPacket::add_answer(DNSAnswer const& answer)
{
m_answers.empend(answer);
@ -85,7 +85,7 @@ public:
u16 data_length() const { return m_data_length; }
void* data() { return this + 1; }
const void* data() const { return this + 1; }
void const* data() const { return this + 1; }
private:
NetworkOrdered<u16> m_type;
@ -96,14 +96,14 @@ private:
static_assert(sizeof(DNSRecordWithoutName) == 10);
Optional<DNSPacket> DNSPacket::from_raw_packet(const u8* raw_data, size_t raw_size)
Optional<DNSPacket> DNSPacket::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));
return {};
}
auto& header = *(const DNSPacketHeader*)(raw_data);
auto& header = *(DNSPacketHeader 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());
@ -127,7 +127,7 @@ Optional<DNSPacket> DNSPacket::from_raw_packet(const u8* raw_data, size_t raw_si
NetworkOrdered<u16> record_type;
NetworkOrdered<u16> class_code;
};
auto& record_and_class = *(const RawDNSAnswerQuestion*)&raw_data[offset];
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);
@ -139,7 +139,7 @@ Optional<DNSPacket> DNSPacket::from_raw_packet(const u8* raw_data, size_t raw_si
for (u16 i = 0; i < header.answer_count(); ++i) {
auto name = DNSName::parse(raw_data, offset, raw_size);
auto& record = *(const DNSRecordWithoutName*)(&raw_data[offset]);
auto& record = *(DNSRecordWithoutName const*)(&raw_data[offset]);
String data;

10
Userland/Services/LookupServer/DNSPacket.h
View file

@ -24,7 +24,7 @@ class DNSPacket {
public:
DNSPacket() = default;
static Optional<DNSPacket> from_raw_packet(const u8*, size_t);
static Optional<DNSPacket> 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; }
const Vector<DNSQuestion>& questions() const { return m_questions; }
const Vector<DNSAnswer>& answers() const { return m_answers; }
Vector<DNSQuestion> const& questions() const { return m_questions; }
Vector<DNSAnswer> const& answers() const { return m_answers; }
u16 question_count() const
{
@ -56,8 +56,8 @@ public:
return m_answers.size();
}
void add_question(const DNSQuestion&);
void add_answer(const DNSAnswer&);
void add_question(DNSQuestion const&);
void add_answer(DNSAnswer const&);
enum class Code : u8 {
NOERROR = 0,

2
Userland/Services/LookupServer/DNSPacketHeader.h
View file

@ -72,7 +72,7 @@ public:
void set_additional_count(u16 w) { m_additional_count = w; }
void* payload() { return this + 1; }
const void* payload() const { return this + 1; }
void const* payload() const { return this + 1; }
private:
NetworkOrdered<u16> m_id;

4
Userland/Services/LookupServer/DNSQuestion.h
View file

@ -15,7 +15,7 @@ namespace LookupServer {
class DNSQuestion {
public:
DNSQuestion(const DNSName& name, DNSRecordType record_type, DNSRecordClass class_code, bool mdns_wants_unicast_response)
DNSQuestion(DNSName const& name, DNSRecordType record_type, DNSRecordClass class_code, bool mdns_wants_unicast_response)
: m_name(name)
, m_record_type(record_type)
, m_class_code(class_code)
@ -26,7 +26,7 @@ public:
DNSRecordType record_type() const { return m_record_type; }
DNSRecordClass 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); }
const DNSName& name() const { return m_name; }
DNSName const& name() const { return m_name; }
bool mdns_wants_unicast_response() const { return m_mdns_wants_unicast_response; }
private:

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

@ -78,7 +78,7 @@ LookupServer::LookupServer()
void LookupServer::load_etc_hosts()
{
m_etc_hosts.clear();
auto add_answer = [this](const DNSName& name, DNSRecordType record_type, String data) {
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);
};
@ -115,7 +115,7 @@ void LookupServer::load_etc_hosts()
auto raw_addr = maybe_address->to_in_addr_t();
DNSName name { fields[1] };
add_answer(name, DNSRecordType::A, String { (const char*)&raw_addr, sizeof(raw_addr) });
add_answer(name, DNSRecordType::A, String { (char const*)&raw_addr, sizeof(raw_addr) });
StringBuilder builder;
builder.append(maybe_address->to_string_reversed());
@ -131,12 +131,12 @@ static String get_hostname()
return buffer;
}
ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(const DNSName& name, DNSRecordType record_type)
ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, DNSRecordType record_type)
{
dbgln_if(LOOKUPSERVER_DEBUG, "Got request for '{}'", name.as_string());
Vector<DNSAnswer> answers;
auto add_answer = [&](const DNSAnswer& answer) {
auto add_answer = [&](DNSAnswer const& answer) {
DNSAnswer answer_with_original_case {
name,
answer.type(),
@ -163,7 +163,7 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(const DNSName& name, DNSRecordTy
if (record_type == DNSRecordType::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 { (const char*)&raw_address, sizeof(raw_address) }, false };
DNSAnswer answer { name, DNSRecordType::A, DNSRecordClass::IN, s_static_ttl, String { (char const*)&raw_address, sizeof(raw_address) }, false };
answers.append(move(answer));
return answers;
}
@ -221,7 +221,7 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(const DNSName& name, DNSRecordTy
return answers;
}
ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(const DNSName& name, const String& nameserver, bool& did_get_response, DNSRecordType record_type, ShouldRandomizeCase should_randomize_case)
ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(DNSName const& name, String const& nameserver, bool& did_get_response, DNSRecordType record_type, ShouldRandomizeCase should_randomize_case)
{
DNSPacket request;
request.set_is_query();
@ -300,7 +300,7 @@ ErrorOr<Vector<DNSAnswer>> LookupServer::lookup(const DNSName& name, const Strin
return answers;
}
void LookupServer::put_in_cache(const DNSAnswer& answer)
void LookupServer::put_in_cache(DNSAnswer const& answer)
{
if (answer.has_expired())
return;

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

@ -24,15 +24,15 @@ class LookupServer final : public Core::Object {
public:
static LookupServer& the();
ErrorOr<Vector<DNSAnswer>> lookup(const DNSName& name, DNSRecordType record_type);
ErrorOr<Vector<DNSAnswer>> lookup(DNSName const& name, DNSRecordType record_type);
private:
LookupServer();
void load_etc_hosts();
void put_in_cache(const DNSAnswer&);
void put_in_cache(DNSAnswer const&);
ErrorOr<Vector<DNSAnswer>> lookup(const DNSName& hostname, const String& nameserver, bool& did_get_response, DNSRecordType record_type, ShouldRandomizeCase = ShouldRandomizeCase::Yes);
ErrorOr<Vector<DNSAnswer>> lookup(DNSName const& hostname, String const& nameserver, bool& did_get_response, DNSRecordType record_type, ShouldRandomizeCase = ShouldRandomizeCase::Yes);
OwnPtr<IPC::MultiServer<ConnectionFromClient>> m_server;
RefPtr<DNSServer> m_dns_server;

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

@ -64,7 +64,7 @@ void MulticastDNS::handle_packet()
handle_query(packet);
}
void MulticastDNS::handle_query(const DNSPacket& packet)
void MulticastDNS::handle_query(DNSPacket const& packet)
{
bool should_reply = false;
@ -94,7 +94,7 @@ void MulticastDNS::announce()
DNSRecordType::A,
DNSRecordClass::IN,
120,
String { (const char*)&raw_addr, sizeof(raw_addr) },
String { (char const*)&raw_addr, sizeof(raw_addr) },
true,
};
response.add_answer(answer);
@ -104,7 +104,7 @@ void MulticastDNS::announce()
perror("Failed to emit response packet");
}
ErrorOr<size_t> MulticastDNS::emit_packet(const DNSPacket& packet, const sockaddr_in* destination)
ErrorOr<size_t> MulticastDNS::emit_packet(DNSPacket const& packet, sockaddr_in const* destination)
{
auto buffer = packet.to_byte_buffer();
if (!destination)
@ -142,7 +142,7 @@ Vector<IPv4Address> MulticastDNS::local_addresses() const
return addresses;
}
Vector<DNSAnswer> MulticastDNS::lookup(const DNSName& name, DNSRecordType record_type)
Vector<DNSAnswer> MulticastDNS::lookup(DNSName const& name, DNSRecordType record_type)
{
DNSPacket request;
request.set_is_query();

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

@ -18,16 +18,16 @@ namespace LookupServer {
class MulticastDNS : public Core::UDPServer {
C_OBJECT(MulticastDNS)
public:
Vector<DNSAnswer> lookup(const DNSName&, DNSRecordType record_type);
Vector<DNSAnswer> lookup(DNSName const&, DNSRecordType record_type);
private:
explicit MulticastDNS(Object* parent = nullptr);
void announce();
ErrorOr<size_t> emit_packet(const DNSPacket&, const sockaddr_in* destination = nullptr);
ErrorOr<size_t> emit_packet(DNSPacket const&, sockaddr_in const* destination = nullptr);
void handle_packet();
void handle_query(const DNSPacket&);
void handle_query(DNSPacket const&);
Vector<IPv4Address> local_addresses() const;