RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 23:17: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

16
Kernel/Net/ARP.h
View file

@ -43,17 +43,17 @@ public:
u16 operation() const { return m_operation; }
void set_operation(u16 w) { m_operation = w; }
const MACAddress& sender_hardware_address() const { return m_sender_hardware_address; }
void set_sender_hardware_address(const MACAddress& address) { m_sender_hardware_address = address; }
MACAddress const& sender_hardware_address() const { return m_sender_hardware_address; }
void set_sender_hardware_address(MACAddress const& address) { m_sender_hardware_address = address; }
const IPv4Address& sender_protocol_address() const { return m_sender_protocol_address; }
void set_sender_protocol_address(const IPv4Address& address) { m_sender_protocol_address = address; }
IPv4Address const& sender_protocol_address() const { return m_sender_protocol_address; }
void set_sender_protocol_address(IPv4Address const& address) { m_sender_protocol_address = address; }
const MACAddress& target_hardware_address() const { return m_target_hardware_address; }
void set_target_hardware_address(const MACAddress& address) { m_target_hardware_address = address; }
MACAddress const& target_hardware_address() const { return m_target_hardware_address; }
void set_target_hardware_address(MACAddress const& address) { m_target_hardware_address = address; }
const IPv4Address& target_protocol_address() const { return m_target_protocol_address; }
void set_target_protocol_address(const IPv4Address& address) { m_target_protocol_address = address; }
IPv4Address const& target_protocol_address() const { return m_target_protocol_address; }
void set_target_protocol_address(IPv4Address const& address) { m_target_protocol_address = address; }
private:
NetworkOrdered<u16> m_hardware_type { ARPHardwareType::Ethernet };

6
Kernel/Net/EthernetFrameHeader.h
View file

@ -17,15 +17,15 @@ public:
~EthernetFrameHeader() = default;
MACAddress destination() const { return m_destination; }
void set_destination(const MACAddress& address) { m_destination = address; }
void set_destination(MACAddress const& address) { m_destination = address; }
MACAddress source() const { return m_source; }
void set_source(const MACAddress& address) { m_source = address; }
void set_source(MACAddress const& address) { m_source = address; }
u16 ether_type() const { return m_ether_type; }
void set_ether_type(u16 ether_type) { m_ether_type = ether_type; }
const void* payload() const { return &m_payload[0]; }
void const* payload() const { return &m_payload[0]; }
void* payload() { return &m_payload[0]; }
private:

4
Kernel/Net/ICMP.h
View file

@ -30,7 +30,7 @@ public:
u16 checksum() const { return m_checksum; }
void set_checksum(u16 w) { m_checksum = w; }
const void* payload() const { return this + 1; }
void const* payload() const { return this + 1; }
void* payload() { return this + 1; }
private:
@ -47,5 +47,5 @@ struct [[gnu::packed]] ICMPEchoPacket {
NetworkOrdered<u16> identifier;
NetworkOrdered<u16> sequence_number;
void* payload() { return this + 1; }
const void* payload() const { return this + 1; }
void const* payload() const { return this + 1; }
};

16
Kernel/Net/IPv4.h
View file

@ -24,7 +24,7 @@ enum class IPv4PacketFlags : u16 {
MoreFragments = 0x2000,
};
NetworkOrdered<u16> internet_checksum(const void*, size_t);
NetworkOrdered<u16> internet_checksum(void const*, size_t);
class [[gnu::packed]] IPv4Packet {
public:
@ -52,14 +52,14 @@ public:
u16 checksum() const { return m_checksum; }
void set_checksum(u16 checksum) { m_checksum = checksum; }
const IPv4Address& source() const { return m_source; }
void set_source(const IPv4Address& address) { m_source = address; }
IPv4Address const& source() const { return m_source; }
void set_source(IPv4Address const& address) { m_source = address; }
const IPv4Address& destination() const { return m_destination; }
void set_destination(const IPv4Address& address) { m_destination = address; }
IPv4Address const& destination() const { return m_destination; }
void set_destination(IPv4Address const& address) { m_destination = address; }
void* payload() { return this + 1; }
const void* payload() const { return this + 1; }
void const* payload() const { return this + 1; }
u16 flags_and_fragment() const { return m_flags_and_fragment; }
u16 fragment_offset() const { return ((u16)m_flags_and_fragment & 0x1fff); }
@ -106,10 +106,10 @@ private:
static_assert(AssertSize<IPv4Packet, 20>());
inline NetworkOrdered<u16> internet_checksum(const void* ptr, size_t count)
inline NetworkOrdered<u16> internet_checksum(void const* ptr, size_t count)
{
u32 checksum = 0;
auto* w = (const u16*)ptr;
auto* w = (u16 const*)ptr;
while (count > 1) {
checksum += AK::convert_between_host_and_network_endian(*w++);
if (checksum & 0x80000000)

42
Kernel/Net/IPv4Socket.cpp
View file

@ -94,7 +94,7 @@ void IPv4Socket::get_peer_address(sockaddr* address, socklen_t* address_size)
*address_size = sizeof(sockaddr_in);
}
ErrorOr<void> IPv4Socket::bind(Userspace<const sockaddr*> user_address, socklen_t address_size)
ErrorOr<void> IPv4Socket::bind(Userspace<sockaddr const*> user_address, socklen_t address_size)
{
VERIFY(setup_state() == SetupState::Unstarted);
if (address_size != sizeof(sockaddr_in))
@ -114,7 +114,7 @@ ErrorOr<void> IPv4Socket::bind(Userspace<const sockaddr*> user_address, socklen_
}
}
m_local_address = IPv4Address((const u8*)&address.sin_addr.s_addr);
m_local_address = IPv4Address((u8 const*)&address.sin_addr.s_addr);
m_local_port = requested_local_port;
dbgln_if(IPV4_SOCKET_DEBUG, "IPv4Socket::bind {}({}) to {}:{}", class_name(), this, m_local_address, m_local_port);
@ -138,12 +138,12 @@ ErrorOr<void> IPv4Socket::listen(size_t backlog)
return protocol_listen(result.did_allocate);
}
ErrorOr<void> IPv4Socket::connect(OpenFileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock should_block)
ErrorOr<void> IPv4Socket::connect(OpenFileDescription& description, Userspace<sockaddr const*> address, socklen_t address_size, ShouldBlock should_block)
{
if (address_size != sizeof(sockaddr_in))
return set_so_error(EINVAL);
u16 sa_family_copy;
auto* user_address = reinterpret_cast<const sockaddr*>(address.unsafe_userspace_ptr());
auto* user_address = reinterpret_cast<sockaddr const*>(address.unsafe_userspace_ptr());
SOCKET_TRY(copy_from_user(&sa_family_copy, &user_address->sa_family, sizeof(u16)));
if (sa_family_copy != AF_INET)
return set_so_error(EINVAL);
@ -153,7 +153,7 @@ ErrorOr<void> IPv4Socket::connect(OpenFileDescription& description, Userspace<co
sockaddr_in safe_address {};
SOCKET_TRY(copy_from_user(&safe_address, (sockaddr_in const*)user_address, sizeof(sockaddr_in)));
m_peer_address = IPv4Address((const u8*)&safe_address.sin_addr.s_addr);
m_peer_address = IPv4Address((u8 const*)&safe_address.sin_addr.s_addr);
if (m_peer_address == IPv4Address { 0, 0, 0, 0 })
m_peer_address = IPv4Address { 127, 0, 0, 1 };
m_peer_port = ntohs(safe_address.sin_port);
@ -161,7 +161,7 @@ ErrorOr<void> IPv4Socket::connect(OpenFileDescription& description, Userspace<co
return protocol_connect(description, should_block);
}
bool IPv4Socket::can_read(const OpenFileDescription&, u64) const
bool IPv4Socket::can_read(OpenFileDescription const&, u64) const
{
if (m_role == Role::Listener)
return can_accept();
@ -170,7 +170,7 @@ bool IPv4Socket::can_read(const OpenFileDescription&, u64) const
return m_can_read;
}
bool IPv4Socket::can_write(const OpenFileDescription&, u64) const
bool IPv4Socket::can_write(OpenFileDescription const&, u64) const
{
return true;
}
@ -187,7 +187,7 @@ PortAllocationResult IPv4Socket::allocate_local_port_if_needed()
return { m_local_port, true };
}
ErrorOr<size_t> IPv4Socket::sendto(OpenFileDescription&, const UserOrKernelBuffer& data, size_t data_length, [[maybe_unused]] int flags, Userspace<const sockaddr*> addr, socklen_t addr_length)
ErrorOr<size_t> IPv4Socket::sendto(OpenFileDescription&, UserOrKernelBuffer const& data, size_t data_length, [[maybe_unused]] int flags, Userspace<sockaddr const*> addr, socklen_t addr_length)
{
MutexLocker locker(mutex());
@ -196,14 +196,14 @@ ErrorOr<size_t> IPv4Socket::sendto(OpenFileDescription&, const UserOrKernelBuffe
if (addr) {
sockaddr_in ia {};
SOCKET_TRY(copy_from_user(&ia, Userspace<const sockaddr_in*>(addr.ptr())));
SOCKET_TRY(copy_from_user(&ia, Userspace<sockaddr_in const*>(addr.ptr())));
if (ia.sin_family != AF_INET) {
dmesgln("sendto: Bad address family: {} is not AF_INET", ia.sin_family);
return set_so_error(EAFNOSUPPORT);
}
m_peer_address = IPv4Address((const u8*)&ia.sin_addr.s_addr);
m_peer_address = IPv4Address((u8 const*)&ia.sin_addr.s_addr);
m_peer_port = ntohs(ia.sin_port);
}
@ -413,7 +413,7 @@ ErrorOr<size_t> IPv4Socket::recvfrom(OpenFileDescription& description, UserOrKer
return total_nreceived;
}
bool IPv4Socket::did_receive(const IPv4Address& source_address, u16 source_port, ReadonlyBytes packet, const Time& packet_timestamp)
bool IPv4Socket::did_receive(IPv4Address const& source_address, u16 source_port, ReadonlyBytes packet, Time const& packet_timestamp)
{
MutexLocker locker(mutex());
@ -468,7 +468,7 @@ bool IPv4Socket::did_receive(const IPv4Address& source_address, u16 source_port,
return true;
}
ErrorOr<NonnullOwnPtr<KString>> IPv4Socket::pseudo_path(const OpenFileDescription&) const
ErrorOr<NonnullOwnPtr<KString>> IPv4Socket::pseudo_path(OpenFileDescription const&) const
{
if (m_role == Role::None)
return KString::try_create("socket"sv);
@ -500,7 +500,7 @@ ErrorOr<NonnullOwnPtr<KString>> IPv4Socket::pseudo_path(const OpenFileDescriptio
return KString::try_create(builder.string_view());
}
ErrorOr<void> IPv4Socket::setsockopt(int level, int option, Userspace<const void*> user_value, socklen_t user_value_size)
ErrorOr<void> IPv4Socket::setsockopt(int level, int option, Userspace<void const*> user_value, socklen_t user_value_size)
{
if (level != IPPROTO_IP)
return Socket::setsockopt(level, option, user_value, user_value_size);
@ -512,7 +512,7 @@ ErrorOr<void> IPv4Socket::setsockopt(int level, int option, Userspace<const void
if (user_value_size < sizeof(int))
return EINVAL;
int value;
TRY(copy_from_user(&value, static_ptr_cast<const int*>(user_value)));
TRY(copy_from_user(&value, static_ptr_cast<int const*>(user_value)));
if (value < 0 || value > 255)
return EINVAL;
m_ttl = value;
@ -522,7 +522,7 @@ ErrorOr<void> IPv4Socket::setsockopt(int level, int option, Userspace<const void
if (user_value_size < sizeof(int))
return EINVAL;
int value;
TRY(copy_from_user(&value, static_ptr_cast<const int*>(user_value)));
TRY(copy_from_user(&value, static_ptr_cast<int const*>(user_value)));
if (value < 0 || value > 255)
return EINVAL;
m_type_of_service = value;
@ -532,7 +532,7 @@ ErrorOr<void> IPv4Socket::setsockopt(int level, int option, Userspace<const void
if (user_value_size != 1)
return EINVAL;
u8 value;
TRY(copy_from_user(&value, static_ptr_cast<const u8*>(user_value)));
TRY(copy_from_user(&value, static_ptr_cast<u8 const*>(user_value)));
if (value != 0 && value != 1)
return EINVAL;
m_multicast_loop = value;
@ -542,10 +542,10 @@ ErrorOr<void> IPv4Socket::setsockopt(int level, int option, Userspace<const void
if (user_value_size != sizeof(ip_mreq))
return EINVAL;
ip_mreq mreq;
TRY(copy_from_user(&mreq, static_ptr_cast<const ip_mreq*>(user_value)));
TRY(copy_from_user(&mreq, static_ptr_cast<ip_mreq const*>(user_value)));
if (mreq.imr_interface.s_addr != INADDR_ANY)
return ENOTSUP;
IPv4Address address { (const u8*)&mreq.imr_multiaddr.s_addr };
IPv4Address address { (u8 const*)&mreq.imr_multiaddr.s_addr };
if (!m_multicast_memberships.contains_slow(address))
m_multicast_memberships.append(address);
return {};
@ -554,10 +554,10 @@ ErrorOr<void> IPv4Socket::setsockopt(int level, int option, Userspace<const void
if (user_value_size != sizeof(ip_mreq))
return EINVAL;
ip_mreq mreq;
TRY(copy_from_user(&mreq, static_ptr_cast<const ip_mreq*>(user_value)));
TRY(copy_from_user(&mreq, static_ptr_cast<ip_mreq const*>(user_value)));
if (mreq.imr_interface.s_addr != INADDR_ANY)
return ENOTSUP;
IPv4Address address { (const u8*)&mreq.imr_multiaddr.s_addr };
IPv4Address address { (u8 const*)&mreq.imr_multiaddr.s_addr };
m_multicast_memberships.remove_first_matching([&address](auto& a) { return a == address; });
return {};
}
@ -596,7 +596,7 @@ ErrorOr<void> IPv4Socket::getsockopt(OpenFileDescription& description, int level
case IP_MULTICAST_LOOP: {
if (size < 1)
return EINVAL;
TRY(copy_to_user(static_ptr_cast<u8*>(value), (const u8*)&m_multicast_loop));
TRY(copy_to_user(static_ptr_cast<u8*>(value), (u8 const*)&m_multicast_loop));
size = 1;
return copy_to_user(value_size, &size);
}

24
Kernel/Net/IPv4Socket.h
View file

@ -32,36 +32,36 @@ public:
virtual ~IPv4Socket() override;
virtual ErrorOr<void> close() override;
virtual ErrorOr<void> bind(Userspace<const sockaddr*>, socklen_t) override;
virtual ErrorOr<void> connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
virtual ErrorOr<void> bind(Userspace<sockaddr const*>, socklen_t) override;
virtual ErrorOr<void> connect(OpenFileDescription&, Userspace<sockaddr const*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
virtual ErrorOr<void> listen(size_t) override;
virtual void get_local_address(sockaddr*, socklen_t*) override;
virtual void get_peer_address(sockaddr*, socklen_t*) override;
virtual bool can_read(const OpenFileDescription&, u64) const override;
virtual bool can_write(const OpenFileDescription&, u64) const override;
virtual ErrorOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
virtual bool can_read(OpenFileDescription const&, u64) const override;
virtual bool can_write(OpenFileDescription const&, u64) const override;
virtual ErrorOr<size_t> sendto(OpenFileDescription&, UserOrKernelBuffer const&, size_t, int, Userspace<sockaddr const*>, socklen_t) override;
virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
virtual ErrorOr<void> setsockopt(int level, int option, Userspace<const void*>, socklen_t) override;
virtual ErrorOr<void> setsockopt(int level, int option, Userspace<void const*>, socklen_t) override;
virtual ErrorOr<void> getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
bool did_receive(const IPv4Address& peer_address, u16 peer_port, ReadonlyBytes, const Time&);
bool did_receive(IPv4Address const& peer_address, u16 peer_port, ReadonlyBytes, Time const&);
const IPv4Address& local_address() const { return m_local_address; }
IPv4Address const& local_address() const { return m_local_address; }
u16 local_port() const { return m_local_port; }
void set_local_port(u16 port) { m_local_port = port; }
bool has_specific_local_address() { return m_local_address.to_u32() != 0; }
const IPv4Address& peer_address() const { return m_peer_address; }
IPv4Address const& peer_address() const { return m_peer_address; }
u16 peer_port() const { return m_peer_port; }
void set_peer_port(u16 port) { m_peer_port = port; }
const Vector<IPv4Address>& multicast_memberships() const { return m_multicast_memberships; }
Vector<IPv4Address> const& multicast_memberships() const { return m_multicast_memberships; }
IPv4SocketTuple tuple() const { return IPv4SocketTuple(m_local_address, m_local_port, m_peer_address, m_peer_port); }
ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription& description) const override;
ErrorOr<NonnullOwnPtr<KString>> pseudo_path(OpenFileDescription const& description) const override;
u8 type_of_service() const { return m_type_of_service; }
u8 ttl() const { return m_ttl; }
@ -81,7 +81,7 @@ protected:
virtual ErrorOr<void> protocol_bind() { return {}; }
virtual ErrorOr<void> protocol_listen([[maybe_unused]] bool did_allocate_port) { return {}; }
virtual ErrorOr<size_t> protocol_receive(ReadonlyBytes /* raw_ipv4_packet */, UserOrKernelBuffer&, size_t, int) { return ENOTIMPL; }
virtual ErrorOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) { return ENOTIMPL; }
virtual ErrorOr<size_t> protocol_send(UserOrKernelBuffer const&, size_t) { return ENOTIMPL; }
virtual ErrorOr<void> protocol_connect(OpenFileDescription&, ShouldBlock) { return {}; }
virtual ErrorOr<u16> protocol_allocate_local_port() { return ENOPROTOOPT; }
virtual ErrorOr<size_t> protocol_size(ReadonlyBytes /* raw_ipv4_packet */) { return ENOTIMPL; }

4
Kernel/Net/IPv4SocketTuple.h
View file

@ -29,7 +29,7 @@ public:
IPv4Address peer_address() const { return m_peer_address; };
u16 peer_port() const { return m_peer_port; };
bool operator==(const IPv4SocketTuple& other) const
bool operator==(IPv4SocketTuple const& other) const
{
return other.local_address() == m_local_address && other.local_port() == m_local_port && other.peer_address() == m_peer_address && other.peer_port() == m_peer_port;
};
@ -57,7 +57,7 @@ namespace AK {
template<>
struct Traits<Kernel::IPv4SocketTuple> : public GenericTraits<Kernel::IPv4SocketTuple> {
static unsigned hash(const Kernel::IPv4SocketTuple& tuple)
static unsigned hash(Kernel::IPv4SocketTuple const& tuple)
{
auto h1 = pair_int_hash(tuple.local_address().to_u32(), tuple.local_port());
auto h2 = pair_int_hash(tuple.peer_address().to_u32(), tuple.peer_port());

2
Kernel/Net/Intel/E1000ENetworkAdapter.cpp
View file

@ -222,7 +222,7 @@ UNMAP_AFTER_INIT bool E1000ENetworkAdapter::initialize()
detect_eeprom();
dmesgln("E1000e: Has EEPROM? {}", m_has_eeprom);
read_mac_address();
const auto& mac = mac_address();
auto const& mac = mac_address();
dmesgln("E1000e: MAC address: {}", mac.to_string());
initialize_rx_descriptors();

16
Kernel/Net/Intel/E1000NetworkAdapter.cpp
View file

@ -213,7 +213,7 @@ UNMAP_AFTER_INIT bool E1000NetworkAdapter::initialize()
detect_eeprom();
dmesgln("E1000: Has EEPROM? {}", m_has_eeprom);
read_mac_address();
const auto& mac = mac_address();
auto const& mac = mac_address();
dmesgln("E1000: MAC address: {}", mac.to_string());
initialize_rx_descriptors();
@ -238,7 +238,7 @@ UNMAP_AFTER_INIT E1000NetworkAdapter::E1000NetworkAdapter(PCI::Address address,
UNMAP_AFTER_INIT E1000NetworkAdapter::~E1000NetworkAdapter() = default;
bool E1000NetworkAdapter::handle_irq(const RegisterState&)
bool E1000NetworkAdapter::handle_irq(RegisterState const&)
{
u32 status = in32(REG_INTERRUPT_CAUSE_READ);
@ -370,7 +370,7 @@ void E1000NetworkAdapter::out8(u16 address, u8 data)
{
dbgln_if(E1000_DEBUG, "E1000: OUT8 {:#02x} @ {:#04x}", data, address);
if (m_use_mmio) {
auto* ptr = (volatile u8*)(m_mmio_base.get() + address);
auto* ptr = (u8 volatile*)(m_mmio_base.get() + address);
*ptr = data;
return;
}
@ -381,7 +381,7 @@ void E1000NetworkAdapter::out16(u16 address, u16 data)
{
dbgln_if(E1000_DEBUG, "E1000: OUT16 {:#04x} @ {:#04x}", data, address);
if (m_use_mmio) {
auto* ptr = (volatile u16*)(m_mmio_base.get() + address);
auto* ptr = (u16 volatile*)(m_mmio_base.get() + address);
*ptr = data;
return;
}
@ -392,7 +392,7 @@ void E1000NetworkAdapter::out32(u16 address, u32 data)
{
dbgln_if(E1000_DEBUG, "E1000: OUT32 {:#08x} @ {:#04x}", data, address);
if (m_use_mmio) {
auto* ptr = (volatile u32*)(m_mmio_base.get() + address);
auto* ptr = (u32 volatile*)(m_mmio_base.get() + address);
*ptr = data;
return;
}
@ -403,7 +403,7 @@ u8 E1000NetworkAdapter::in8(u16 address)
{
dbgln_if(E1000_DEBUG, "E1000: IN8 @ {:#04x}", address);
if (m_use_mmio)
return *(volatile u8*)(m_mmio_base.get() + address);
return *(u8 volatile*)(m_mmio_base.get() + address);
return m_io_base.offset(address).in<u8>();
}
@ -411,7 +411,7 @@ u16 E1000NetworkAdapter::in16(u16 address)
{
dbgln_if(E1000_DEBUG, "E1000: IN16 @ {:#04x}", address);
if (m_use_mmio)
return *(volatile u16*)(m_mmio_base.get() + address);
return *(u16 volatile*)(m_mmio_base.get() + address);
return m_io_base.offset(address).in<u16>();
}
@ -419,7 +419,7 @@ u32 E1000NetworkAdapter::in32(u16 address)
{
dbgln_if(E1000_DEBUG, "E1000: IN32 @ {:#04x}", address);
if (m_use_mmio)
return *(volatile u32*)(m_mmio_base.get() + address);
return *(u32 volatile*)(m_mmio_base.get() + address);
return m_io_base.offset(address).in<u32>();
}

2
Kernel/Net/Intel/E1000NetworkAdapter.h
View file

@ -38,7 +38,7 @@ protected:
void setup_link();
E1000NetworkAdapter(PCI::Address, u8 irq, NonnullOwnPtr<KString>);
virtual bool handle_irq(const RegisterState&) override;
virtual bool handle_irq(RegisterState const&) override;
virtual StringView class_name() const override { return "E1000NetworkAdapter"sv; }
struct [[gnu::packed]] e1000_rx_desc {

30
Kernel/Net/LocalSocket.cpp
View file

@ -27,16 +27,16 @@ static MutexProtected<LocalSocket::List>& all_sockets()
return *s_list;
}
void LocalSocket::for_each(Function<void(const LocalSocket&)> callback)
void LocalSocket::for_each(Function<void(LocalSocket const&)> callback)
{
all_sockets().for_each_shared([&](const auto& socket) {
all_sockets().for_each_shared([&](auto const& socket) {
callback(socket);
});
}
ErrorOr<void> LocalSocket::try_for_each(Function<ErrorOr<void>(const LocalSocket&)> callback)
ErrorOr<void> LocalSocket::try_for_each(Function<ErrorOr<void>(LocalSocket const&)> callback)
{
return all_sockets().with_shared([&](const auto& sockets) -> ErrorOr<void> {
return all_sockets().with_shared([&](auto const& sockets) -> ErrorOr<void> {
for (auto& socket : sockets)
TRY(callback(socket));
return {};
@ -115,7 +115,7 @@ void LocalSocket::get_peer_address(sockaddr* address, socklen_t* address_size)
get_local_address(address, address_size);
}
ErrorOr<void> LocalSocket::bind(Userspace<const sockaddr*> user_address, socklen_t address_size)
ErrorOr<void> LocalSocket::bind(Userspace<sockaddr const*> user_address, socklen_t address_size)
{
VERIFY(setup_state() == SetupState::Unstarted);
if (address_size != sizeof(sockaddr_un))
@ -153,13 +153,13 @@ ErrorOr<void> LocalSocket::bind(Userspace<const sockaddr*> user_address, socklen
return {};
}
ErrorOr<void> LocalSocket::connect(OpenFileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock)
ErrorOr<void> LocalSocket::connect(OpenFileDescription& description, Userspace<sockaddr const*> address, socklen_t address_size, ShouldBlock)
{
VERIFY(!m_bound);
if (address_size != sizeof(sockaddr_un))
return set_so_error(EINVAL);
u16 sa_family_copy;
auto* user_address = reinterpret_cast<const sockaddr*>(address.unsafe_userspace_ptr());
auto* user_address = reinterpret_cast<sockaddr const*>(address.unsafe_userspace_ptr());
SOCKET_TRY(copy_from_user(&sa_family_copy, &user_address->sa_family, sizeof(u16)));
if (sa_family_copy != AF_LOCAL)
return set_so_error(EINVAL);
@ -268,7 +268,7 @@ void LocalSocket::detach(OpenFileDescription& description)
evaluate_block_conditions();
}
bool LocalSocket::can_read(const OpenFileDescription& description, u64) const
bool LocalSocket::can_read(OpenFileDescription const& description, u64) const
{
auto role = this->role(description);
if (role == Role::Listener)
@ -280,7 +280,7 @@ bool LocalSocket::can_read(const OpenFileDescription& description, u64) const
return false;
}
bool LocalSocket::has_attached_peer(const OpenFileDescription& description) const
bool LocalSocket::has_attached_peer(OpenFileDescription const& description) const
{
auto role = this->role(description);
if (role == Role::Accepted)
@ -290,7 +290,7 @@ bool LocalSocket::has_attached_peer(const OpenFileDescription& description) cons
return false;
}
bool LocalSocket::can_write(const OpenFileDescription& description, u64) const
bool LocalSocket::can_write(OpenFileDescription const& description, u64) const
{
auto role = this->role(description);
if (role == Role::Accepted)
@ -300,7 +300,7 @@ bool LocalSocket::can_write(const OpenFileDescription& description, u64) const
return false;
}
ErrorOr<size_t> LocalSocket::sendto(OpenFileDescription& description, const UserOrKernelBuffer& data, size_t data_size, int, Userspace<const sockaddr*>, socklen_t)
ErrorOr<size_t> LocalSocket::sendto(OpenFileDescription& description, UserOrKernelBuffer const& data, size_t data_size, int, Userspace<sockaddr const*>, socklen_t)
{
if (!has_attached_peer(description))
return set_so_error(EPIPE);
@ -365,7 +365,7 @@ StringView LocalSocket::socket_path() const
return m_path->view();
}
ErrorOr<NonnullOwnPtr<KString>> LocalSocket::pseudo_path(const OpenFileDescription& description) const
ErrorOr<NonnullOwnPtr<KString>> LocalSocket::pseudo_path(OpenFileDescription const& description) const
{
StringBuilder builder;
TRY(builder.try_append("socket:"));
@ -469,7 +469,7 @@ ErrorOr<void> LocalSocket::chown(OpenFileDescription&, UserID uid, GroupID gid)
return {};
}
NonnullRefPtrVector<OpenFileDescription>& LocalSocket::recvfd_queue_for(const OpenFileDescription& description)
NonnullRefPtrVector<OpenFileDescription>& LocalSocket::recvfd_queue_for(OpenFileDescription const& description)
{
auto role = this->role(description);
if (role == Role::Connected)
@ -479,7 +479,7 @@ NonnullRefPtrVector<OpenFileDescription>& LocalSocket::recvfd_queue_for(const Op
VERIFY_NOT_REACHED();
}
NonnullRefPtrVector<OpenFileDescription>& LocalSocket::sendfd_queue_for(const OpenFileDescription& description)
NonnullRefPtrVector<OpenFileDescription>& LocalSocket::sendfd_queue_for(OpenFileDescription const& description)
{
auto role = this->role(description);
if (role == Role::Connected)
@ -503,7 +503,7 @@ ErrorOr<void> LocalSocket::sendfd(OpenFileDescription const& socket_description,
return {};
}
ErrorOr<NonnullRefPtr<OpenFileDescription>> LocalSocket::recvfd(const OpenFileDescription& socket_description)
ErrorOr<NonnullRefPtr<OpenFileDescription>> LocalSocket::recvfd(OpenFileDescription const& socket_description)
{
MutexLocker locker(mutex());
auto role = this->role(socket_description);

26
Kernel/Net/LocalSocket.h
View file

@ -27,25 +27,25 @@ public:
virtual ~LocalSocket() override;
ErrorOr<void> sendfd(OpenFileDescription const& socket_description, NonnullRefPtr<OpenFileDescription> passing_description);
ErrorOr<NonnullRefPtr<OpenFileDescription>> recvfd(const OpenFileDescription& socket_description);
ErrorOr<NonnullRefPtr<OpenFileDescription>> recvfd(OpenFileDescription const& socket_description);
static void for_each(Function<void(const LocalSocket&)>);
static ErrorOr<void> try_for_each(Function<ErrorOr<void>(const LocalSocket&)>);
static void for_each(Function<void(LocalSocket const&)>);
static ErrorOr<void> try_for_each(Function<ErrorOr<void>(LocalSocket const&)>);
StringView socket_path() const;
ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription& description) const override;
ErrorOr<NonnullOwnPtr<KString>> pseudo_path(OpenFileDescription const& description) const override;
// ^Socket
virtual ErrorOr<void> bind(Userspace<const sockaddr*>, socklen_t) override;
virtual ErrorOr<void> connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
virtual ErrorOr<void> bind(Userspace<sockaddr const*>, socklen_t) override;
virtual ErrorOr<void> connect(OpenFileDescription&, Userspace<sockaddr const*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
virtual ErrorOr<void> listen(size_t) override;
virtual void get_local_address(sockaddr*, socklen_t*) override;
virtual void get_peer_address(sockaddr*, socklen_t*) override;
virtual ErrorOr<void> attach(OpenFileDescription&) override;
virtual void detach(OpenFileDescription&) override;
virtual bool can_read(const OpenFileDescription&, u64) const override;
virtual bool can_write(const OpenFileDescription&, u64) const override;
virtual ErrorOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
virtual bool can_read(OpenFileDescription const&, u64) const override;
virtual bool can_write(OpenFileDescription const&, u64) const override;
virtual ErrorOr<size_t> sendto(OpenFileDescription&, UserOrKernelBuffer const&, size_t, int, Userspace<sockaddr const*>, socklen_t) override;
virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
virtual ErrorOr<void> getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
@ -56,11 +56,11 @@ private:
explicit LocalSocket(int type, NonnullOwnPtr<DoubleBuffer> client_buffer, NonnullOwnPtr<DoubleBuffer> server_buffer);
virtual StringView class_name() const override { return "LocalSocket"sv; }
virtual bool is_local() const override { return true; }
bool has_attached_peer(const OpenFileDescription&) const;
bool has_attached_peer(OpenFileDescription const&) const;
DoubleBuffer* receive_buffer_for(OpenFileDescription&);
DoubleBuffer* send_buffer_for(OpenFileDescription&);
NonnullRefPtrVector<OpenFileDescription>& sendfd_queue_for(const OpenFileDescription&);
NonnullRefPtrVector<OpenFileDescription>& recvfd_queue_for(const OpenFileDescription&);
NonnullRefPtrVector<OpenFileDescription>& sendfd_queue_for(OpenFileDescription const&);
NonnullRefPtrVector<OpenFileDescription>& recvfd_queue_for(OpenFileDescription const&);
void set_connect_side_role(Role connect_side_role, bool force_evaluate_block_conditions = false)
{
@ -86,7 +86,7 @@ private:
Role m_connect_side_role { Role::None };
OpenFileDescription* m_connect_side_fd { nullptr };
virtual Role role(const OpenFileDescription& description) const override
virtual Role role(OpenFileDescription const& description) const override
{
if (m_connect_side_fd == &description)
return m_connect_side_role;

2
Kernel/Net/NE2000/NetworkAdapter.cpp
View file

@ -187,7 +187,7 @@ UNMAP_AFTER_INIT NE2000NetworkAdapter::NE2000NetworkAdapter(PCI::Address address
UNMAP_AFTER_INIT NE2000NetworkAdapter::~NE2000NetworkAdapter() = default;
bool NE2000NetworkAdapter::handle_irq(const RegisterState&)
bool NE2000NetworkAdapter::handle_irq(RegisterState const&)
{
u8 status = in8(REG_RW_INTERRUPTSTATUS);

2
Kernel/Net/NE2000/NetworkAdapter.h
View file

@ -42,7 +42,7 @@ public:
private:
NE2000NetworkAdapter(PCI::Address, u8, NonnullOwnPtr<KString>);
virtual bool handle_irq(const RegisterState&) override;
virtual bool handle_irq(RegisterState const&) override;
virtual StringView class_name() const override { return "NE2000NetworkAdapter"sv; }
int ram_test();

10
Kernel/Net/NetworkAdapter.cpp
View file

@ -28,7 +28,7 @@ void NetworkAdapter::send_packet(ReadonlyBytes packet)
send_raw(packet);
}
void NetworkAdapter::send(const MACAddress& destination, const ARPPacket& packet)
void NetworkAdapter::send(MACAddress const& destination, ARPPacket const& packet)
{
size_t size_in_bytes = sizeof(EthernetFrameHeader) + sizeof(ARPPacket);
auto buffer_result = NetworkByteBuffer::create_zeroed(size_in_bytes);
@ -41,7 +41,7 @@ void NetworkAdapter::send(const MACAddress& destination, const ARPPacket& packet
eth->set_destination(destination);
eth->set_ether_type(EtherType::ARP);
memcpy(eth->payload(), &packet, sizeof(ARPPacket));
send_packet({ (const u8*)eth, size_in_bytes });
send_packet({ (u8 const*)eth, size_in_bytes });
}
void NetworkAdapter::fill_in_ipv4_header(PacketWithTimestamp& packet, IPv4Address const& source_ipv4, MACAddress const& destination_mac, IPv4Address const& destination_ipv4, IPv4Protocol protocol, size_t payload_size, u8 type_of_service, u8 ttl)
@ -149,17 +149,17 @@ void NetworkAdapter::release_packet_buffer(PacketWithTimestamp& packet)
m_unused_packets.append(packet);
}
void NetworkAdapter::set_ipv4_address(const IPv4Address& address)
void NetworkAdapter::set_ipv4_address(IPv4Address const& address)
{
m_ipv4_address = address;
}
void NetworkAdapter::set_ipv4_netmask(const IPv4Address& netmask)
void NetworkAdapter::set_ipv4_netmask(IPv4Address const& netmask)
{
m_ipv4_netmask = netmask;
}
void NetworkAdapter::set_ipv4_gateway(const IPv4Address& gateway)
void NetworkAdapter::set_ipv4_gateway(IPv4Address const& gateway)
{
m_ipv4_gateway = gateway;
}

10
Kernel/Net/NetworkAdapter.h
View file

@ -64,11 +64,11 @@ public:
}
virtual bool link_full_duplex() { return false; }
void set_ipv4_address(const IPv4Address&);
void set_ipv4_netmask(const IPv4Address&);
void set_ipv4_gateway(const IPv4Address&);
void set_ipv4_address(IPv4Address const&);
void set_ipv4_netmask(IPv4Address const&);
void set_ipv4_gateway(IPv4Address const&);
void send(const MACAddress&, const ARPPacket&);
void send(MACAddress const&, ARPPacket const&);
void fill_in_ipv4_header(PacketWithTimestamp&, IPv4Address const&, MACAddress const&, IPv4Address const&, IPv4Protocol, size_t, u8 type_of_service, u8 ttl);
size_t dequeue_packet(u8* buffer, size_t buffer_size, Time& packet_timestamp);
@ -95,7 +95,7 @@ public:
protected:
NetworkAdapter(NonnullOwnPtr<KString>);
void set_mac_address(const MACAddress& mac_address) { m_mac_address = mac_address; }
void set_mac_address(MACAddress const& mac_address) { m_mac_address = mac_address; }
void did_receive(ReadonlyBytes);
virtual void send_raw(ReadonlyBytes) = 0;

2
Kernel/Net/NetworkTask.cpp
View file

@ -658,7 +658,7 @@ void retransmit_tcp_packets()
// We must keep the sockets alive until after we've unlocked the hash table
// in case retransmit_packets() realizes that it wants to close the socket.
NonnullRefPtrVector<TCPSocket, 16> sockets;
TCPSocket::sockets_for_retransmit().for_each_shared([&](const auto& socket) {
TCPSocket::sockets_for_retransmit().for_each_shared([&](auto const& socket) {
// We ignore allocation failures above the first 16 guaranteed socket slots, as
// we will just retransmit their packets the next time around
(void)sockets.try_append(socket);

2
Kernel/Net/NetworkingManagement.h
View file

@ -33,7 +33,7 @@ public:
void for_each(Function<void(NetworkAdapter&)>);
ErrorOr<void> try_for_each(Function<ErrorOr<void>(NetworkAdapter&)>);
RefPtr<NetworkAdapter> from_ipv4_address(const IPv4Address&) const;
RefPtr<NetworkAdapter> from_ipv4_address(IPv4Address const&) const;
RefPtr<NetworkAdapter> lookup_by_name(StringView) const;
NonnullRefPtr<NetworkAdapter> loopback_adapter() const;

10
Kernel/Net/Realtek/RTL8139NetworkAdapter.cpp
View file

@ -156,7 +156,7 @@ UNMAP_AFTER_INIT RTL8139NetworkAdapter::RTL8139NetworkAdapter(PCI::Address addre
reset();
read_mac_address();
const auto& mac = mac_address();
auto const& mac = mac_address();
dmesgln("RTL8139: MAC address: {}", mac.to_string());
enable_irq();
@ -164,7 +164,7 @@ UNMAP_AFTER_INIT RTL8139NetworkAdapter::RTL8139NetworkAdapter(PCI::Address addre
UNMAP_AFTER_INIT RTL8139NetworkAdapter::~RTL8139NetworkAdapter() = default;
bool RTL8139NetworkAdapter::handle_irq(const RegisterState&)
bool RTL8139NetworkAdapter::handle_irq(RegisterState const&)
{
bool was_handled = false;
for (;;) {
@ -324,8 +324,8 @@ void RTL8139NetworkAdapter::receive()
{
auto* start_of_packet = m_rx_buffer->vaddr().as_ptr() + m_rx_buffer_offset;
u16 status = *(const u16*)(start_of_packet + 0);
u16 length = *(const u16*)(start_of_packet + 2);
u16 status = *(u16 const*)(start_of_packet + 0);
u16 length = *(u16 const*)(start_of_packet + 2);
dbgln_if(RTL8139_DEBUG, "RTL8139: receive, status={:#04x}, length={}, offset={}", status, length, m_rx_buffer_offset);
@ -338,7 +338,7 @@ void RTL8139NetworkAdapter::receive()
// we never have to worry about the packet wrapping around the buffer,
// since we set RXCFG_WRAP_INHIBIT, which allows the rtl8139 to write data
// past the end of the allotted space.
memcpy(m_packet_buffer->vaddr().as_ptr(), (const u8*)(start_of_packet + 4), length - 4);
memcpy(m_packet_buffer->vaddr().as_ptr(), (u8 const*)(start_of_packet + 4), length - 4);
// let the card know that we've read this data
m_rx_buffer_offset = ((m_rx_buffer_offset + length + 4 + 3) & ~3) % RX_BUFFER_SIZE;
out16(REG_CAPR, m_rx_buffer_offset - 0x10);

2
Kernel/Net/Realtek/RTL8139NetworkAdapter.h
View file

@ -35,7 +35,7 @@ public:
private:
RTL8139NetworkAdapter(PCI::Address, u8 irq, NonnullOwnPtr<KString>);
virtual bool handle_irq(const RegisterState&) override;
virtual bool handle_irq(RegisterState const&) override;
virtual StringView class_name() const override { return "RTL8139NetworkAdapter"sv; }
void reset();

2
Kernel/Net/Realtek/RTL8168NetworkAdapter.cpp
View file

@ -1127,7 +1127,7 @@ UNMAP_AFTER_INIT void RTL8168NetworkAdapter::initialize_tx_descriptors()
UNMAP_AFTER_INIT RTL8168NetworkAdapter::~RTL8168NetworkAdapter() = default;
bool RTL8168NetworkAdapter::handle_irq(const RegisterState&)
bool RTL8168NetworkAdapter::handle_irq(RegisterState const&)
{
bool was_handled = false;
for (;;) {

2
Kernel/Net/Realtek/RTL8168NetworkAdapter.h
View file

@ -40,7 +40,7 @@ private:
RTL8168NetworkAdapter(PCI::Address, u8 irq, NonnullOwnPtr<KString>);
virtual bool handle_irq(const RegisterState&) override;
virtual bool handle_irq(RegisterState const&) override;
virtual StringView class_name() const override { return "RTL8168NetworkAdapter"sv; }
bool determine_supported_version() const;

6
Kernel/Net/Routing.cpp
View file

@ -70,7 +70,7 @@ protected:
{
VERIFY(b.blocker_type() == Thread::Blocker::Type::Routing);
auto& blocker = static_cast<ARPTableBlocker&>(b);
auto maybe_mac_address = arp_table().with([&](auto const& table) -> auto {
auto maybe_mac_address = arp_table().with([&](auto const& table) -> auto{
return table.get(blocker.ip_address());
});
if (!maybe_mac_address.has_value())
@ -94,7 +94,7 @@ bool ARPTableBlocker::setup_blocker()
void ARPTableBlocker::will_unblock_immediately_without_blocking(UnblockImmediatelyReason)
{
auto addr = arp_table().with([&](auto const& table) -> auto {
auto addr = arp_table().with([&](auto const& table) -> auto{
return table.get(ip_address());
});
@ -232,7 +232,7 @@ RoutingDecision route_to(IPv4Address const& target, IPv4Address const& source, R
return { adapter, multicast_ethernet_address(target) };
{
auto addr = arp_table().with([&](auto const& table) -> auto {
auto addr = arp_table().with([&](auto const& table) -> auto{
return table.get(next_hop_ip);
});
if (addr.has_value()) {

6
Kernel/Net/Socket.cpp
View file

@ -74,7 +74,7 @@ ErrorOr<void> Socket::queue_connection_from(NonnullRefPtr<Socket> peer)
return {};
}
ErrorOr<void> Socket::setsockopt(int level, int option, Userspace<const void*> user_value, socklen_t user_value_size)
ErrorOr<void> Socket::setsockopt(int level, int option, Userspace<void const*> user_value, socklen_t user_value_size)
{
MutexLocker locker(mutex());
@ -95,7 +95,7 @@ ErrorOr<void> Socket::setsockopt(int level, int option, Userspace<const void*> u
case SO_BINDTODEVICE: {
if (user_value_size != IFNAMSIZ)
return EINVAL;
auto user_string = static_ptr_cast<const char*>(user_value);
auto user_string = static_ptr_cast<char const*>(user_value);
auto ifname = TRY(try_copy_kstring_from_user(user_string, user_value_size));
auto device = NetworkingManagement::the().lookup_by_name(ifname->view());
if (!device)
@ -242,7 +242,7 @@ ErrorOr<size_t> Socket::read(OpenFileDescription& description, u64, UserOrKernel
return recvfrom(description, buffer, size, 0, {}, 0, t);
}
ErrorOr<size_t> Socket::write(OpenFileDescription& description, u64, const UserOrKernelBuffer& data, size_t size)
ErrorOr<size_t> Socket::write(OpenFileDescription& description, u64, UserOrKernelBuffer const& data, size_t size)
{
if (is_shut_down_for_writing())
return set_so_error(EPIPE);

20
Kernel/Net/Socket.h
View file

@ -68,7 +68,7 @@ public:
SetupState setup_state() const { return m_setup_state; }
void set_setup_state(SetupState setup_state);
virtual Role role(const OpenFileDescription&) const { return m_role; }
virtual Role role(OpenFileDescription const&) const { return m_role; }
bool is_connected() const { return m_connected; }
void set_connected(bool);
@ -78,17 +78,17 @@ public:
ErrorOr<void> shutdown(int how);
virtual ErrorOr<void> bind(Userspace<const sockaddr*>, socklen_t) = 0;
virtual ErrorOr<void> connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock) = 0;
virtual ErrorOr<void> bind(Userspace<sockaddr const*>, socklen_t) = 0;
virtual ErrorOr<void> connect(OpenFileDescription&, Userspace<sockaddr const*>, socklen_t, ShouldBlock) = 0;
virtual ErrorOr<void> listen(size_t) = 0;
virtual void get_local_address(sockaddr*, socklen_t*) = 0;
virtual void get_peer_address(sockaddr*, socklen_t*) = 0;
virtual bool is_local() const { return false; }
virtual bool is_ipv4() const { return false; }
virtual ErrorOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int flags, Userspace<const sockaddr*>, socklen_t) = 0;
virtual ErrorOr<size_t> sendto(OpenFileDescription&, UserOrKernelBuffer const&, size_t, int flags, Userspace<sockaddr const*>, socklen_t) = 0;
virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) = 0;
virtual ErrorOr<void> setsockopt(int level, int option, Userspace<const void*>, socklen_t);
virtual ErrorOr<void> setsockopt(int level, int option, Userspace<void const*>, socklen_t);
virtual ErrorOr<void> getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>);
ProcessID origin_pid() const { return m_origin.pid; }
@ -97,21 +97,21 @@ public:
ProcessID acceptor_pid() const { return m_acceptor.pid; }
UserID acceptor_uid() const { return m_acceptor.uid; }
GroupID acceptor_gid() const { return m_acceptor.gid; }
const RefPtr<NetworkAdapter> bound_interface() const { return m_bound_interface; }
RefPtr<NetworkAdapter> const bound_interface() const { return m_bound_interface; }
Mutex& mutex() { return m_mutex; }
// ^File
virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override final;
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override final;
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override final;
virtual ErrorOr<struct stat> stat() const override;
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override = 0;
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(OpenFileDescription const&) const override = 0;
bool has_receive_timeout() const { return m_receive_timeout != Time::zero(); }
const Time& receive_timeout() const { return m_receive_timeout; }
Time const& receive_timeout() const { return m_receive_timeout; }
bool has_send_timeout() const { return m_send_timeout != Time::zero(); }
const Time& send_timeout() const { return m_send_timeout; }
Time const& send_timeout() const { return m_send_timeout; }
bool wants_timestamp() const { return m_timestamp; }

2
Kernel/Net/TCP.h
View file

@ -78,7 +78,7 @@ public:
u16 urgent() const { return m_urgent; }
void set_urgent(u16 urgent) { m_urgent = urgent; }
const void* payload() const { return ((const u8*)this) + header_size(); }
void const* payload() const { return ((u8 const*)this) + header_size(); }
void* payload() { return ((u8*)this) + header_size(); }
private:

36
Kernel/Net/TCPSocket.cpp
View file

@ -22,16 +22,16 @@
namespace Kernel {
void TCPSocket::for_each(Function<void(const TCPSocket&)> callback)
void TCPSocket::for_each(Function<void(TCPSocket const&)> callback)
{
sockets_by_tuple().for_each_shared([&](const auto& it) {
sockets_by_tuple().for_each_shared([&](auto const& it) {
callback(*it.value);
});
}
ErrorOr<void> TCPSocket::try_for_each(Function<ErrorOr<void>(const TCPSocket&)> callback)
ErrorOr<void> TCPSocket::try_for_each(Function<ErrorOr<void>(TCPSocket const&)> callback)
{
return sockets_by_tuple().with_shared([&](const auto& sockets) -> ErrorOr<void> {
return sockets_by_tuple().with_shared([&](auto const& sockets) -> ErrorOr<void> {
for (auto& it : sockets)
TRY(callback(*it.value));
return {};
@ -102,9 +102,9 @@ MutexProtected<HashMap<IPv4SocketTuple, TCPSocket*>>& TCPSocket::sockets_by_tupl
return *s_socket_tuples;
}
RefPtr<TCPSocket> TCPSocket::from_tuple(const IPv4SocketTuple& tuple)
RefPtr<TCPSocket> TCPSocket::from_tuple(IPv4SocketTuple const& tuple)
{
return sockets_by_tuple().with_shared([&](const auto& table) -> RefPtr<TCPSocket> {
return sockets_by_tuple().with_shared([&](auto const& table) -> RefPtr<TCPSocket> {
auto exact_match = table.get(tuple);
if (exact_match.has_value())
return { *exact_match.value() };
@ -122,7 +122,7 @@ RefPtr<TCPSocket> TCPSocket::from_tuple(const IPv4SocketTuple& tuple)
return {};
});
}
ErrorOr<NonnullRefPtr<TCPSocket>> TCPSocket::try_create_client(const IPv4Address& new_local_address, u16 new_local_port, const IPv4Address& new_peer_address, u16 new_peer_port)
ErrorOr<NonnullRefPtr<TCPSocket>> TCPSocket::try_create_client(IPv4Address const& new_local_address, u16 new_local_port, IPv4Address const& new_peer_address, u16 new_peer_port)
{
auto tuple = IPv4SocketTuple(new_local_address, new_local_port, new_peer_address, new_peer_port);
return sockets_by_tuple().with_exclusive([&](auto& table) -> ErrorOr<NonnullRefPtr<TCPSocket>> {
@ -184,15 +184,15 @@ ErrorOr<NonnullRefPtr<TCPSocket>> TCPSocket::try_create(int protocol, NonnullOwn
ErrorOr<size_t> TCPSocket::protocol_size(ReadonlyBytes raw_ipv4_packet)
{
auto& ipv4_packet = *reinterpret_cast<const IPv4Packet*>(raw_ipv4_packet.data());
auto& tcp_packet = *static_cast<const TCPPacket*>(ipv4_packet.payload());
auto& ipv4_packet = *reinterpret_cast<IPv4Packet const*>(raw_ipv4_packet.data());
auto& tcp_packet = *static_cast<TCPPacket const*>(ipv4_packet.payload());
return raw_ipv4_packet.size() - sizeof(IPv4Packet) - tcp_packet.header_size();
}
ErrorOr<size_t> TCPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
{
auto& ipv4_packet = *reinterpret_cast<const IPv4Packet*>(raw_ipv4_packet.data());
auto& tcp_packet = *static_cast<const TCPPacket*>(ipv4_packet.payload());
auto& ipv4_packet = *reinterpret_cast<IPv4Packet const*>(raw_ipv4_packet.data());
auto& tcp_packet = *static_cast<TCPPacket const*>(ipv4_packet.payload());
size_t payload_size = raw_ipv4_packet.size() - sizeof(IPv4Packet) - tcp_packet.header_size();
dbgln_if(TCP_SOCKET_DEBUG, "payload_size {}, will it fit in {}?", payload_size, buffer_size);
VERIFY(buffer_size >= payload_size);
@ -200,7 +200,7 @@ ErrorOr<size_t> TCPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserO
return payload_size;
}
ErrorOr<size_t> TCPSocket::protocol_send(const UserOrKernelBuffer& data, size_t data_length)
ErrorOr<size_t> TCPSocket::protocol_send(UserOrKernelBuffer const& data, size_t data_length)
{
RoutingDecision routing_decision = route_to(peer_address(), local_address(), bound_interface());
if (routing_decision.is_zero())
@ -218,7 +218,7 @@ ErrorOr<void> TCPSocket::send_ack(bool allow_duplicate)
return send_tcp_packet(TCPFlags::ACK);
}
ErrorOr<void> TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* payload, size_t payload_size, RoutingDecision* user_routing_decision)
ErrorOr<void> TCPSocket::send_tcp_packet(u16 flags, UserOrKernelBuffer const* payload, size_t payload_size, RoutingDecision* user_routing_decision)
{
RoutingDecision routing_decision = user_routing_decision ? *user_routing_decision : route_to(peer_address(), local_address(), bound_interface());
if (routing_decision.is_zero())
@ -226,7 +226,7 @@ ErrorOr<void> TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* pa
auto ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
const bool has_mss_option = flags == TCPFlags::SYN;
bool const has_mss_option = flags == TCPFlags::SYN;
const size_t options_size = has_mss_option ? sizeof(TCPOptionMSS) : 0;
const size_t tcp_header_size = sizeof(TCPPacket) + options_size;
const size_t buffer_size = ipv4_payload_offset + tcp_header_size + payload_size;
@ -291,7 +291,7 @@ ErrorOr<void> TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* pa
return {};
}
void TCPSocket::receive_tcp_packet(const TCPPacket& packet, u16 size)
void TCPSocket::receive_tcp_packet(TCPPacket const& packet, u16 size)
{
if (packet.has_ack()) {
u32 ack_number = packet.ack_number();
@ -349,7 +349,7 @@ bool TCPSocket::should_delay_next_ack() const
return true;
}
NetworkOrdered<u16> TCPSocket::compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket& packet, u16 payload_size)
NetworkOrdered<u16> TCPSocket::compute_tcp_checksum(IPv4Address const& source, IPv4Address const& destination, TCPPacket const& packet, u16 payload_size)
{
struct [[gnu::packed]] PseudoHeader {
IPv4Address source;
@ -382,7 +382,7 @@ NetworkOrdered<u16> TCPSocket::compute_tcp_checksum(const IPv4Address& source, c
checksum = (checksum >> 16) + (checksum & 0xffff);
}
if (payload_size & 1) {
u16 expanded_byte = ((const u8*)packet.payload())[payload_size - 1] << 8;
u16 expanded_byte = ((u8 const*)packet.payload())[payload_size - 1] << 8;
checksum += expanded_byte;
if (checksum > 0xffff)
checksum = (checksum >> 16) + (checksum & 0xffff);
@ -623,7 +623,7 @@ void TCPSocket::retransmit_packets()
});
}
bool TCPSocket::can_write(const OpenFileDescription& file_description, u64 size) const
bool TCPSocket::can_write(OpenFileDescription const& file_description, u64 size) const
{
if (!IPv4Socket::can_write(file_description, size))
return false;

14
Kernel/Net/TCPSocket.h
View file

@ -18,8 +18,8 @@ namespace Kernel {
class TCPSocket final : public IPv4Socket {
public:
static void for_each(Function<void(const TCPSocket&)>);
static ErrorOr<void> try_for_each(Function<ErrorOr<void>(const TCPSocket&)>);
static void for_each(Function<void(TCPSocket const&)>);
static ErrorOr<void> try_for_each(Function<ErrorOr<void>(TCPSocket const&)>);
static ErrorOr<NonnullRefPtr<TCPSocket>> try_create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer);
virtual ~TCPSocket() override;
@ -140,13 +140,13 @@ public:
u32 duplicate_acks() const { return m_duplicate_acks; }
ErrorOr<void> send_ack(bool allow_duplicate = false);
ErrorOr<void> send_tcp_packet(u16 flags, const UserOrKernelBuffer* = nullptr, size_t = 0, RoutingDecision* = nullptr);
void receive_tcp_packet(const TCPPacket&, u16 size);
ErrorOr<void> send_tcp_packet(u16 flags, UserOrKernelBuffer const* = nullptr, size_t = 0, RoutingDecision* = nullptr);
void receive_tcp_packet(TCPPacket const&, u16 size);
bool should_delay_next_ack() const;
static MutexProtected<HashMap<IPv4SocketTuple, TCPSocket*>>& sockets_by_tuple();
static RefPtr<TCPSocket> from_tuple(const IPv4SocketTuple& tuple);
static RefPtr<TCPSocket> from_tuple(IPv4SocketTuple const& tuple);
static MutexProtected<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& closing_sockets();
@ -160,7 +160,7 @@ public:
virtual ErrorOr<void> close() override;
virtual bool can_write(const OpenFileDescription&, u64) const override;
virtual bool can_write(OpenFileDescription const&, u64) const override;
static NetworkOrdered<u16> compute_tcp_checksum(IPv4Address const& source, IPv4Address const& destination, TCPPacket const&, u16 payload_size);
@ -174,7 +174,7 @@ private:
virtual void shut_down_for_writing() override;
virtual ErrorOr<size_t> protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags) override;
virtual ErrorOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) override;
virtual ErrorOr<size_t> protocol_send(UserOrKernelBuffer const&, size_t) override;
virtual ErrorOr<void> protocol_connect(OpenFileDescription&, ShouldBlock) override;
virtual ErrorOr<u16> protocol_allocate_local_port() override;
virtual ErrorOr<size_t> protocol_size(ReadonlyBytes raw_ipv4_packet) override;

2
Kernel/Net/UDP.h
View file

@ -27,7 +27,7 @@ public:
u16 checksum() const { return m_checksum; }
void set_checksum(u16 checksum) { m_checksum = checksum; }
const void* payload() const { return this + 1; }
void const* payload() const { return this + 1; }
void* payload() { return this + 1; }
private:

20
Kernel/Net/UDPSocket.cpp
View file

@ -15,16 +15,16 @@
namespace Kernel {
void UDPSocket::for_each(Function<void(const UDPSocket&)> callback)
void UDPSocket::for_each(Function<void(UDPSocket const&)> callback)
{
sockets_by_port().for_each_shared([&](const auto& socket) {
sockets_by_port().for_each_shared([&](auto const& socket) {
callback(*socket.value);
});
}
ErrorOr<void> UDPSocket::try_for_each(Function<ErrorOr<void>(const UDPSocket&)> callback)
ErrorOr<void> UDPSocket::try_for_each(Function<ErrorOr<void>(UDPSocket const&)> callback)
{
return sockets_by_port().with_shared([&](const auto& sockets) -> ErrorOr<void> {
return sockets_by_port().with_shared([&](auto const& sockets) -> ErrorOr<void> {
for (auto& socket : sockets)
TRY(callback(*socket.value));
return {};
@ -40,7 +40,7 @@ MutexProtected<HashMap<u16, UDPSocket*>>& UDPSocket::sockets_by_port()
RefPtr<UDPSocket> UDPSocket::from_port(u16 port)
{
return sockets_by_port().with_shared([&](const auto& table) -> RefPtr<UDPSocket> {
return sockets_by_port().with_shared([&](auto const& table) -> RefPtr<UDPSocket> {
auto it = table.find(port);
if (it == table.end())
return {};
@ -67,22 +67,22 @@ ErrorOr<NonnullRefPtr<UDPSocket>> UDPSocket::try_create(int protocol, NonnullOwn
ErrorOr<size_t> UDPSocket::protocol_size(ReadonlyBytes raw_ipv4_packet)
{
auto& ipv4_packet = *(const IPv4Packet*)(raw_ipv4_packet.data());
auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
auto& ipv4_packet = *(IPv4Packet const*)(raw_ipv4_packet.data());
auto& udp_packet = *static_cast<UDPPacket const*>(ipv4_packet.payload());
return udp_packet.length() - sizeof(UDPPacket);
}
ErrorOr<size_t> UDPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
{
auto& ipv4_packet = *(const IPv4Packet*)(raw_ipv4_packet.data());
auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
auto& ipv4_packet = *(IPv4Packet const*)(raw_ipv4_packet.data());
auto& udp_packet = *static_cast<UDPPacket const*>(ipv4_packet.payload());
VERIFY(udp_packet.length() >= sizeof(UDPPacket)); // FIXME: This should be rejected earlier.
size_t read_size = min(buffer_size, udp_packet.length() - sizeof(UDPPacket));
SOCKET_TRY(buffer.write(udp_packet.payload(), read_size));
return read_size;
}
ErrorOr<size_t> UDPSocket::protocol_send(const UserOrKernelBuffer& data, size_t data_length)
ErrorOr<size_t> UDPSocket::protocol_send(UserOrKernelBuffer const& data, size_t data_length)
{
auto routing_decision = route_to(peer_address(), local_address(), bound_interface());
if (routing_decision.is_zero())

6
Kernel/Net/UDPSocket.h
View file

@ -18,8 +18,8 @@ public:
virtual ~UDPSocket() override;
static RefPtr<UDPSocket> from_port(u16);
static void for_each(Function<void(const UDPSocket&)>);
static ErrorOr<void> try_for_each(Function<ErrorOr<void>(const UDPSocket&)>);
static void for_each(Function<void(UDPSocket const&)>);
static ErrorOr<void> try_for_each(Function<ErrorOr<void>(UDPSocket const&)>);
private:
explicit UDPSocket(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer);
@ -27,7 +27,7 @@ private:
static MutexProtected<HashMap<u16, UDPSocket*>>& sockets_by_port();
virtual ErrorOr<size_t> protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags) override;
virtual ErrorOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) override;
virtual ErrorOr<size_t> protocol_send(UserOrKernelBuffer const&, size_t) override;
virtual ErrorOr<size_t> protocol_size(ReadonlyBytes raw_ipv4_packet) override;
virtual ErrorOr<void> protocol_connect(OpenFileDescription&, ShouldBlock) override;
virtual ErrorOr<u16> protocol_allocate_local_port() override;