1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 23:17:45 +00:00

Everywhere: Run clang-format

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

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 };

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:

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; }
};

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)

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);
}

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; }

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());

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();

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>();
}

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 {

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);

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;

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);

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();

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;
}

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;

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);

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;

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);

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();

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 (;;) {

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;

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()) {

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);

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; }

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:

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;

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;

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:

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())

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;