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:
parent
0376c127f6
commit
086969277e
1665 changed files with 8479 additions and 8479 deletions
|
@ -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 };
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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; }
|
||||
};
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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; }
|
||||
|
|
|
@ -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());
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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>();
|
||||
}
|
||||
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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 (;;) {
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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()) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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; }
|
||||
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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())
|
||||
|
|
|
@ -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;
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue