mirror of
https://github.com/RGBCube/serenity
synced 2025-07-27 00:17:46 +00:00
Kernel: Rename Locker => MutexLocker
This commit is contained in:
parent
ab50a1480f
commit
9457d83986
40 changed files with 230 additions and 230 deletions
|
@ -66,13 +66,13 @@ IPv4Socket::IPv4Socket(int type, int protocol)
|
|||
if (m_buffer_mode == BufferMode::Bytes) {
|
||||
m_scratch_buffer = KBuffer::create_with_size(65536);
|
||||
}
|
||||
Locker locker(all_sockets().lock());
|
||||
MutexLocker locker(all_sockets().lock());
|
||||
all_sockets().resource().set(this);
|
||||
}
|
||||
|
||||
IPv4Socket::~IPv4Socket()
|
||||
{
|
||||
Locker locker(all_sockets().lock());
|
||||
MutexLocker locker(all_sockets().lock());
|
||||
all_sockets().resource().remove(this);
|
||||
}
|
||||
|
||||
|
@ -121,7 +121,7 @@ KResult IPv4Socket::bind(Userspace<const sockaddr*> user_address, socklen_t addr
|
|||
|
||||
KResult IPv4Socket::listen(size_t backlog)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
auto result = allocate_local_port_if_needed();
|
||||
if (result.error_or_port.is_error() && result.error_or_port.error() != -ENOPROTOOPT)
|
||||
return result.error_or_port.error();
|
||||
|
@ -176,7 +176,7 @@ bool IPv4Socket::can_write(const FileDescription&, size_t) const
|
|||
|
||||
PortAllocationResult IPv4Socket::allocate_local_port_if_needed()
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
if (m_local_port)
|
||||
return { m_local_port, false };
|
||||
auto port_or_error = protocol_allocate_local_port();
|
||||
|
@ -188,7 +188,7 @@ PortAllocationResult IPv4Socket::allocate_local_port_if_needed()
|
|||
|
||||
KResultOr<size_t> IPv4Socket::sendto(FileDescription&, const UserOrKernelBuffer& data, size_t data_length, [[maybe_unused]] int flags, Userspace<const sockaddr*> addr, socklen_t addr_length)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
|
||||
if (addr && addr_length != sizeof(sockaddr_in))
|
||||
return EINVAL;
|
||||
|
@ -247,7 +247,7 @@ KResultOr<size_t> IPv4Socket::sendto(FileDescription&, const UserOrKernelBuffer&
|
|||
|
||||
KResultOr<size_t> IPv4Socket::receive_byte_buffered(FileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
if (m_receive_buffer.is_empty()) {
|
||||
if (protocol_is_disconnected())
|
||||
return 0;
|
||||
|
@ -283,7 +283,7 @@ KResultOr<size_t> IPv4Socket::receive_byte_buffered(FileDescription& description
|
|||
|
||||
KResultOr<size_t> IPv4Socket::receive_packet_buffered(FileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> addr, Userspace<socklen_t*> addr_length, Time& packet_timestamp)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
ReceivedPacket packet;
|
||||
{
|
||||
if (m_receive_queue.is_empty()) {
|
||||
|
@ -398,7 +398,7 @@ KResultOr<size_t> IPv4Socket::recvfrom(FileDescription& description, UserOrKerne
|
|||
|
||||
bool IPv4Socket::did_receive(const IPv4Address& source_address, u16 source_port, ReadonlyBytes packet, const Time& packet_timestamp)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
|
||||
if (is_shut_down_for_reading())
|
||||
return false;
|
||||
|
|
|
@ -26,7 +26,7 @@ static Lockable<LocalSocket::List>& all_sockets()
|
|||
|
||||
void LocalSocket::for_each(Function<void(const LocalSocket&)> callback)
|
||||
{
|
||||
Locker locker(all_sockets().lock(), Mutex::Mode::Shared);
|
||||
MutexLocker locker(all_sockets().lock(), Mutex::Mode::Shared);
|
||||
for (auto& socket : all_sockets().resource())
|
||||
callback(socket);
|
||||
}
|
||||
|
@ -70,7 +70,7 @@ LocalSocket::LocalSocket(int type)
|
|||
: Socket(AF_LOCAL, type, 0)
|
||||
{
|
||||
{
|
||||
Locker locker(all_sockets().lock());
|
||||
MutexLocker locker(all_sockets().lock());
|
||||
all_sockets().resource().append(*this);
|
||||
}
|
||||
|
||||
|
@ -91,7 +91,7 @@ LocalSocket::LocalSocket(int type)
|
|||
|
||||
LocalSocket::~LocalSocket()
|
||||
{
|
||||
Locker locker(all_sockets().lock());
|
||||
MutexLocker locker(all_sockets().lock());
|
||||
all_sockets().resource().remove(*this);
|
||||
}
|
||||
|
||||
|
@ -214,7 +214,7 @@ KResult LocalSocket::connect(FileDescription& description, Userspace<const socka
|
|||
|
||||
KResult LocalSocket::listen(size_t backlog)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
if (type() != SOCK_STREAM)
|
||||
return EOPNOTSUPP;
|
||||
set_backlog(backlog);
|
||||
|
@ -465,7 +465,7 @@ NonnullRefPtrVector<FileDescription>& LocalSocket::sendfd_queue_for(const FileDe
|
|||
|
||||
KResult LocalSocket::sendfd(const FileDescription& socket_description, FileDescription& passing_description)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
auto role = this->role(socket_description);
|
||||
if (role != Role::Connected && role != Role::Accepted)
|
||||
return EINVAL;
|
||||
|
@ -480,7 +480,7 @@ KResult LocalSocket::sendfd(const FileDescription& socket_description, FileDescr
|
|||
|
||||
KResultOr<NonnullRefPtr<FileDescription>> LocalSocket::recvfd(const FileDescription& socket_description)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
auto role = this->role(socket_description);
|
||||
if (role != Role::Connected && role != Role::Accepted)
|
||||
return EINVAL;
|
||||
|
|
|
@ -224,7 +224,7 @@ void handle_icmp(const EthernetFrameHeader& eth, const IPv4Packet& ipv4_packet,
|
|||
{
|
||||
NonnullRefPtrVector<IPv4Socket> icmp_sockets;
|
||||
{
|
||||
Locker locker(IPv4Socket::all_sockets().lock(), Mutex::Mode::Shared);
|
||||
MutexLocker locker(IPv4Socket::all_sockets().lock(), Mutex::Mode::Shared);
|
||||
for (auto* socket : IPv4Socket::all_sockets().resource()) {
|
||||
if (socket->protocol() != (unsigned)IPv4Protocol::ICMP)
|
||||
continue;
|
||||
|
@ -312,7 +312,7 @@ void flush_delayed_tcp_acks()
|
|||
{
|
||||
Vector<RefPtr<TCPSocket>, 32> remaining_sockets;
|
||||
for (auto& socket : *delayed_ack_sockets) {
|
||||
Locker locker(socket->lock());
|
||||
MutexLocker locker(socket->lock());
|
||||
if (socket->should_delay_next_ack()) {
|
||||
remaining_sockets.append(socket);
|
||||
continue;
|
||||
|
@ -395,7 +395,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
|
|||
return;
|
||||
}
|
||||
|
||||
Locker locker(socket->lock());
|
||||
MutexLocker locker(socket->lock());
|
||||
|
||||
VERIFY(socket->type() == SOCK_STREAM);
|
||||
VERIFY(socket->local_port() == tcp_packet.destination_port());
|
||||
|
@ -426,7 +426,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
|
|||
dmesgln("handle_tcp: couldn't create client socket");
|
||||
return;
|
||||
}
|
||||
Locker locker(client->lock());
|
||||
MutexLocker locker(client->lock());
|
||||
dbgln_if(TCP_DEBUG, "handle_tcp: created new client socket with tuple {}", client->tuple().to_string());
|
||||
client->set_sequence_number(1000);
|
||||
client->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
|
||||
|
@ -624,13 +624,13 @@ void retransmit_tcp_packets()
|
|||
// in case retransmit_packets() realizes that it wants to close the socket.
|
||||
NonnullRefPtrVector<TCPSocket, 16> sockets;
|
||||
{
|
||||
Locker locker(TCPSocket::sockets_for_retransmit().lock(), LockMode::Shared);
|
||||
MutexLocker locker(TCPSocket::sockets_for_retransmit().lock(), LockMode::Shared);
|
||||
for (auto& socket : TCPSocket::sockets_for_retransmit().resource())
|
||||
sockets.append(*socket);
|
||||
}
|
||||
|
||||
for (auto& socket : sockets) {
|
||||
Locker socket_locker(socket.lock());
|
||||
MutexLocker socket_locker(socket.lock());
|
||||
socket.retransmit_packets();
|
||||
}
|
||||
}
|
||||
|
|
|
@ -43,14 +43,14 @@ NonnullRefPtr<NetworkAdapter> NetworkingManagement::loopback_adapter() const
|
|||
|
||||
void NetworkingManagement::for_each(Function<void(NetworkAdapter&)> callback)
|
||||
{
|
||||
Locker locker(m_lock);
|
||||
MutexLocker locker(m_lock);
|
||||
for (auto& it : m_adapters)
|
||||
callback(it);
|
||||
}
|
||||
|
||||
RefPtr<NetworkAdapter> NetworkingManagement::from_ipv4_address(const IPv4Address& address) const
|
||||
{
|
||||
Locker locker(m_lock);
|
||||
MutexLocker locker(m_lock);
|
||||
for (auto& adapter : m_adapters) {
|
||||
if (adapter.ipv4_address() == address || adapter.ipv4_broadcast() == address)
|
||||
return adapter;
|
||||
|
@ -63,7 +63,7 @@ RefPtr<NetworkAdapter> NetworkingManagement::from_ipv4_address(const IPv4Address
|
|||
}
|
||||
RefPtr<NetworkAdapter> NetworkingManagement::lookup_by_name(const StringView& name) const
|
||||
{
|
||||
Locker locker(m_lock);
|
||||
MutexLocker locker(m_lock);
|
||||
RefPtr<NetworkAdapter> found_adapter;
|
||||
for (auto& it : m_adapters) {
|
||||
if (it.name() == name)
|
||||
|
|
|
@ -106,7 +106,7 @@ Lockable<HashMap<IPv4Address, MACAddress>>& arp_table()
|
|||
|
||||
void update_arp_table(const IPv4Address& ip_addr, const MACAddress& addr)
|
||||
{
|
||||
Locker locker(arp_table().lock());
|
||||
MutexLocker locker(arp_table().lock());
|
||||
arp_table().resource().set(ip_addr, addr);
|
||||
s_arp_table_block_condition->unblock(ip_addr, addr);
|
||||
|
||||
|
@ -221,7 +221,7 @@ RoutingDecision route_to(const IPv4Address& target, const IPv4Address& source, c
|
|||
return { adapter, multicast_ethernet_address(target) };
|
||||
|
||||
{
|
||||
Locker locker(arp_table().lock());
|
||||
MutexLocker locker(arp_table().lock());
|
||||
auto addr = arp_table().resource().get(next_hop_ip);
|
||||
if (addr.has_value()) {
|
||||
dbgln_if(ROUTING_DEBUG, "Routing: Using cached ARP entry for {} ({})", next_hop_ip, addr.value().to_string());
|
||||
|
|
|
@ -51,7 +51,7 @@ void Socket::set_setup_state(SetupState new_setup_state)
|
|||
|
||||
RefPtr<Socket> Socket::accept()
|
||||
{
|
||||
Locker locker(m_lock);
|
||||
MutexLocker locker(m_lock);
|
||||
if (m_pending.is_empty())
|
||||
return nullptr;
|
||||
dbgln_if(SOCKET_DEBUG, "Socket({}) de-queueing connection", this);
|
||||
|
@ -69,7 +69,7 @@ RefPtr<Socket> Socket::accept()
|
|||
KResult Socket::queue_connection_from(NonnullRefPtr<Socket> peer)
|
||||
{
|
||||
dbgln_if(SOCKET_DEBUG, "Socket({}) queueing connection", this);
|
||||
Locker locker(m_lock);
|
||||
MutexLocker locker(m_lock);
|
||||
if (m_pending.size() >= m_backlog)
|
||||
return ECONNREFUSED;
|
||||
if (!m_pending.try_append(peer))
|
||||
|
@ -241,7 +241,7 @@ KResultOr<size_t> Socket::write(FileDescription& description, u64, const UserOrK
|
|||
|
||||
KResult Socket::shutdown(int how)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
if (type() == SOCK_STREAM && !is_connected())
|
||||
return ENOTCONN;
|
||||
if (m_role == Role::Listener)
|
||||
|
@ -264,7 +264,7 @@ KResult Socket::stat(::stat& st) const
|
|||
|
||||
void Socket::set_connected(bool connected)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
if (m_connected == connected)
|
||||
return;
|
||||
m_connected = connected;
|
||||
|
|
|
@ -23,7 +23,7 @@ namespace Kernel {
|
|||
|
||||
void TCPSocket::for_each(Function<void(const TCPSocket&)> callback)
|
||||
{
|
||||
Locker locker(sockets_by_tuple().lock(), Mutex::Mode::Shared);
|
||||
MutexLocker locker(sockets_by_tuple().lock(), Mutex::Mode::Shared);
|
||||
for (auto& it : sockets_by_tuple().resource())
|
||||
callback(*it.value);
|
||||
}
|
||||
|
@ -41,7 +41,7 @@ void TCPSocket::set_state(State new_state)
|
|||
m_role = Role::Connected;
|
||||
|
||||
if (new_state == State::Closed) {
|
||||
Locker locker(closing_sockets().lock());
|
||||
MutexLocker locker(closing_sockets().lock());
|
||||
closing_sockets().resource().remove(tuple());
|
||||
|
||||
if (m_originator)
|
||||
|
@ -68,7 +68,7 @@ Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>& TCPSocket::sockets_by_tuple()
|
|||
|
||||
RefPtr<TCPSocket> TCPSocket::from_tuple(const IPv4SocketTuple& tuple)
|
||||
{
|
||||
Locker locker(sockets_by_tuple().lock(), Mutex::Mode::Shared);
|
||||
MutexLocker locker(sockets_by_tuple().lock(), Mutex::Mode::Shared);
|
||||
|
||||
auto exact_match = sockets_by_tuple().resource().get(tuple);
|
||||
if (exact_match.has_value())
|
||||
|
@ -91,7 +91,7 @@ RefPtr<TCPSocket> TCPSocket::create_client(const IPv4Address& new_local_address,
|
|||
auto tuple = IPv4SocketTuple(new_local_address, new_local_port, new_peer_address, new_peer_port);
|
||||
|
||||
{
|
||||
Locker locker(sockets_by_tuple().lock(), Mutex::Mode::Shared);
|
||||
MutexLocker locker(sockets_by_tuple().lock(), Mutex::Mode::Shared);
|
||||
if (sockets_by_tuple().resource().contains(tuple))
|
||||
return {};
|
||||
}
|
||||
|
@ -109,7 +109,7 @@ RefPtr<TCPSocket> TCPSocket::create_client(const IPv4Address& new_local_address,
|
|||
client->set_direction(Direction::Incoming);
|
||||
client->set_originator(*this);
|
||||
|
||||
Locker locker(sockets_by_tuple().lock());
|
||||
MutexLocker locker(sockets_by_tuple().lock());
|
||||
m_pending_release_for_accept.set(tuple, client);
|
||||
sockets_by_tuple().resource().set(tuple, client);
|
||||
|
||||
|
@ -139,7 +139,7 @@ TCPSocket::TCPSocket(int protocol)
|
|||
|
||||
TCPSocket::~TCPSocket()
|
||||
{
|
||||
Locker locker(sockets_by_tuple().lock());
|
||||
MutexLocker locker(sockets_by_tuple().lock());
|
||||
sockets_by_tuple().resource().remove(tuple());
|
||||
|
||||
dequeue_for_retransmit();
|
||||
|
@ -246,7 +246,7 @@ KResult TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* payload,
|
|||
m_packets_out++;
|
||||
m_bytes_out += buffer_size;
|
||||
if (tcp_packet.has_syn() || payload_size > 0) {
|
||||
Locker locker(m_not_acked_lock);
|
||||
MutexLocker locker(m_not_acked_lock);
|
||||
m_not_acked.append({ m_sequence_number, move(packet), ipv4_payload_offset, *routing_decision.adapter });
|
||||
m_not_acked_size += payload_size;
|
||||
enqueue_for_retransmit();
|
||||
|
@ -265,7 +265,7 @@ void TCPSocket::receive_tcp_packet(const TCPPacket& packet, u16 size)
|
|||
dbgln_if(TCP_SOCKET_DEBUG, "TCPSocket: receive_tcp_packet: {}", ack_number);
|
||||
|
||||
int removed = 0;
|
||||
Locker locker(m_not_acked_lock);
|
||||
MutexLocker locker(m_not_acked_lock);
|
||||
while (!m_not_acked.is_empty()) {
|
||||
auto& packet = m_not_acked.first();
|
||||
|
||||
|
@ -369,7 +369,7 @@ KResult TCPSocket::protocol_bind()
|
|||
KResult TCPSocket::protocol_listen(bool did_allocate_port)
|
||||
{
|
||||
if (!did_allocate_port) {
|
||||
Locker socket_locker(sockets_by_tuple().lock());
|
||||
MutexLocker socket_locker(sockets_by_tuple().lock());
|
||||
if (sockets_by_tuple().resource().contains(tuple()))
|
||||
return EADDRINUSE;
|
||||
sockets_by_tuple().resource().set(tuple(), this);
|
||||
|
@ -383,7 +383,7 @@ KResult TCPSocket::protocol_listen(bool did_allocate_port)
|
|||
|
||||
KResult TCPSocket::protocol_connect(FileDescription& description, ShouldBlock should_block)
|
||||
{
|
||||
Locker locker(lock());
|
||||
MutexLocker locker(lock());
|
||||
|
||||
auto routing_decision = route_to(peer_address(), local_address());
|
||||
if (routing_decision.is_zero())
|
||||
|
@ -434,7 +434,7 @@ KResultOr<u16> TCPSocket::protocol_allocate_local_port()
|
|||
constexpr u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
|
||||
u16 first_scan_port = first_ephemeral_port + get_good_random<u16>() % ephemeral_port_range_size;
|
||||
|
||||
Locker locker(sockets_by_tuple().lock());
|
||||
MutexLocker locker(sockets_by_tuple().lock());
|
||||
for (u16 port = first_scan_port;;) {
|
||||
IPv4SocketTuple proposed_tuple(local_address(), port, peer_address(), peer_port());
|
||||
|
||||
|
@ -482,7 +482,7 @@ void TCPSocket::shut_down_for_writing()
|
|||
|
||||
KResult TCPSocket::close()
|
||||
{
|
||||
Locker socket_locker(lock());
|
||||
MutexLocker socket_locker(lock());
|
||||
auto result = IPv4Socket::close();
|
||||
if (state() == State::CloseWait) {
|
||||
dbgln_if(TCP_SOCKET_DEBUG, " Sending FIN from CloseWait and moving into LastAck");
|
||||
|
@ -491,7 +491,7 @@ KResult TCPSocket::close()
|
|||
}
|
||||
|
||||
if (state() != State::Closed && state() != State::Listen) {
|
||||
Locker locker(closing_sockets().lock());
|
||||
MutexLocker locker(closing_sockets().lock());
|
||||
closing_sockets().resource().set(tuple(), *this);
|
||||
}
|
||||
return result;
|
||||
|
@ -506,13 +506,13 @@ Lockable<HashTable<TCPSocket*>>& TCPSocket::sockets_for_retransmit()
|
|||
|
||||
void TCPSocket::enqueue_for_retransmit()
|
||||
{
|
||||
Locker locker(sockets_for_retransmit().lock());
|
||||
MutexLocker locker(sockets_for_retransmit().lock());
|
||||
sockets_for_retransmit().resource().set(this);
|
||||
}
|
||||
|
||||
void TCPSocket::dequeue_for_retransmit()
|
||||
{
|
||||
Locker locker(sockets_for_retransmit().lock());
|
||||
MutexLocker locker(sockets_for_retransmit().lock());
|
||||
sockets_for_retransmit().resource().remove(this);
|
||||
}
|
||||
|
||||
|
@ -545,7 +545,7 @@ void TCPSocket::retransmit_packets()
|
|||
if (routing_decision.is_zero())
|
||||
return;
|
||||
|
||||
Locker locker(m_not_acked_lock, Mutex::Mode::Shared);
|
||||
MutexLocker locker(m_not_acked_lock, Mutex::Mode::Shared);
|
||||
for (auto& packet : m_not_acked) {
|
||||
packet.tx_counter++;
|
||||
|
||||
|
@ -590,7 +590,7 @@ bool TCPSocket::can_write(const FileDescription& file_description, size_t size)
|
|||
if (!file_description.is_blocking())
|
||||
return true;
|
||||
|
||||
Locker lock(m_not_acked_lock);
|
||||
MutexLocker lock(m_not_acked_lock);
|
||||
return m_not_acked_size + size <= m_send_window_size;
|
||||
}
|
||||
|
||||
|
|
|
@ -17,7 +17,7 @@ namespace Kernel {
|
|||
|
||||
void UDPSocket::for_each(Function<void(const UDPSocket&)> callback)
|
||||
{
|
||||
Locker locker(sockets_by_port().lock(), Mutex::Mode::Shared);
|
||||
MutexLocker locker(sockets_by_port().lock(), Mutex::Mode::Shared);
|
||||
for (auto it : sockets_by_port().resource())
|
||||
callback(*it.value);
|
||||
}
|
||||
|
@ -33,7 +33,7 @@ SocketHandle<UDPSocket> UDPSocket::from_port(u16 port)
|
|||
{
|
||||
RefPtr<UDPSocket> socket;
|
||||
{
|
||||
Locker locker(sockets_by_port().lock(), Mutex::Mode::Shared);
|
||||
MutexLocker locker(sockets_by_port().lock(), Mutex::Mode::Shared);
|
||||
auto it = sockets_by_port().resource().find(port);
|
||||
if (it == sockets_by_port().resource().end())
|
||||
return {};
|
||||
|
@ -50,7 +50,7 @@ UDPSocket::UDPSocket(int protocol)
|
|||
|
||||
UDPSocket::~UDPSocket()
|
||||
{
|
||||
Locker locker(sockets_by_port().lock());
|
||||
MutexLocker locker(sockets_by_port().lock());
|
||||
sockets_by_port().resource().remove(local_port());
|
||||
}
|
||||
|
||||
|
@ -112,7 +112,7 @@ KResultOr<u16> UDPSocket::protocol_allocate_local_port()
|
|||
constexpr u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
|
||||
u16 first_scan_port = first_ephemeral_port + get_good_random<u16>() % ephemeral_port_range_size;
|
||||
|
||||
Locker locker(sockets_by_port().lock());
|
||||
MutexLocker locker(sockets_by_port().lock());
|
||||
for (u16 port = first_scan_port;;) {
|
||||
auto it = sockets_by_port().resource().find(port);
|
||||
if (it == sockets_by_port().resource().end()) {
|
||||
|
@ -131,7 +131,7 @@ KResultOr<u16> UDPSocket::protocol_allocate_local_port()
|
|||
|
||||
KResult UDPSocket::protocol_bind()
|
||||
{
|
||||
Locker locker(sockets_by_port().lock());
|
||||
MutexLocker locker(sockets_by_port().lock());
|
||||
if (sockets_by_port().resource().contains(local_port()))
|
||||
return EADDRINUSE;
|
||||
sockets_by_port().resource().set(local_port(), this);
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue