jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
3 *
4 * SPDX-License-Identifier: BSD-2-Clause
5 */
6
7#include <AK/Singleton.h>
8#include <Kernel/Devices/RandomDevice.h>
9#include <Kernel/Net/NetworkAdapter.h>
10#include <Kernel/Net/Routing.h>
11#include <Kernel/Net/UDP.h>
12#include <Kernel/Net/UDPSocket.h>
13#include <Kernel/Process.h>
14#include <Kernel/Random.h>
15
16namespace Kernel {
17
18void UDPSocket::for_each(Function<void(UDPSocket const&)> callback)
19{
20 sockets_by_port().for_each_shared([&](auto const& socket) {
21 callback(*socket.value);
22 });
23}
24
25ErrorOr<void> UDPSocket::try_for_each(Function<ErrorOr<void>(UDPSocket const&)> callback)
26{
27 return sockets_by_port().with_shared([&](auto const& sockets) -> ErrorOr<void> {
28 for (auto& socket : sockets)
29 TRY(callback(*socket.value));
30 return {};
31 });
32}
33
34static Singleton<MutexProtected<HashMap<u16, UDPSocket*>>> s_map;
35
36MutexProtected<HashMap<u16, UDPSocket*>>& UDPSocket::sockets_by_port()
37{
38 return *s_map;
39}
40
41RefPtr<UDPSocket> UDPSocket::from_port(u16 port)
42{
43 return sockets_by_port().with_shared([&](auto const& table) -> RefPtr<UDPSocket> {
44 auto it = table.find(port);
45 if (it == table.end())
46 return {};
47 return (*it).value;
48 });
49}
50
51UDPSocket::UDPSocket(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer)
52 : IPv4Socket(SOCK_DGRAM, protocol, move(receive_buffer), {})
53{
54}
55
56UDPSocket::~UDPSocket()
57{
58 sockets_by_port().with_exclusive([&](auto& table) {
59 table.remove(local_port());
60 });
61}
62
63ErrorOr<NonnullRefPtr<UDPSocket>> UDPSocket::try_create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer)
64{
65 return adopt_nonnull_ref_or_enomem(new (nothrow) UDPSocket(protocol, move(receive_buffer)));
66}
67
68ErrorOr<size_t> UDPSocket::protocol_size(ReadonlyBytes raw_ipv4_packet)
69{
70 auto& ipv4_packet = *(IPv4Packet const*)(raw_ipv4_packet.data());
71 auto& udp_packet = *static_cast<UDPPacket const*>(ipv4_packet.payload());
72 return udp_packet.length() - sizeof(UDPPacket);
73}
74
75ErrorOr<size_t> UDPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
76{
77 auto& ipv4_packet = *(IPv4Packet const*)(raw_ipv4_packet.data());
78 auto& udp_packet = *static_cast<UDPPacket const*>(ipv4_packet.payload());
79 VERIFY(udp_packet.length() >= sizeof(UDPPacket)); // FIXME: This should be rejected earlier.
80 size_t read_size = min(buffer_size, udp_packet.length() - sizeof(UDPPacket));
81 SOCKET_TRY(buffer.write(udp_packet.payload(), read_size));
82 return read_size;
83}
84
85ErrorOr<size_t> UDPSocket::protocol_send(UserOrKernelBuffer const& data, size_t data_length)
86{
87 auto routing_decision = route_to(peer_address(), local_address(), bound_interface());
88 if (routing_decision.is_zero())
89 return set_so_error(EHOSTUNREACH);
90 auto ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
91 data_length = min(data_length, routing_decision.adapter->mtu() - ipv4_payload_offset - sizeof(UDPPacket));
92 const size_t udp_buffer_size = sizeof(UDPPacket) + data_length;
93 auto packet = routing_decision.adapter->acquire_packet_buffer(ipv4_payload_offset + udp_buffer_size);
94 if (!packet)
95 return set_so_error(ENOMEM);
96 memset(packet->buffer->data() + ipv4_payload_offset, 0, sizeof(UDPPacket));
97 auto& udp_packet = *reinterpret_cast<UDPPacket*>(packet->buffer->data() + ipv4_payload_offset);
98 udp_packet.set_source_port(local_port());
99 udp_packet.set_destination_port(peer_port());
100 udp_packet.set_length(udp_buffer_size);
101 SOCKET_TRY(data.read(udp_packet.payload(), data_length));
102 routing_decision.adapter->fill_in_ipv4_header(*packet, local_address(), routing_decision.next_hop,
103 peer_address(), IPv4Protocol::UDP, udp_buffer_size, type_of_service(), ttl());
104 routing_decision.adapter->send_packet(packet->bytes());
105 return data_length;
106}
107
108ErrorOr<void> UDPSocket::protocol_connect(OpenFileDescription&)
109{
110 set_role(Role::Connected);
111 set_connected(true);
112 return {};
113}
114
115ErrorOr<u16> UDPSocket::protocol_allocate_local_port()
116{
117 constexpr u16 first_ephemeral_port = 32768;
118 constexpr u16 last_ephemeral_port = 60999;
119 constexpr u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
120 u16 first_scan_port = first_ephemeral_port + get_good_random<u16>() % ephemeral_port_range_size;
121
122 return sockets_by_port().with_exclusive([&](auto& table) -> ErrorOr<u16> {
123 for (u16 port = first_scan_port;;) {
124 auto it = table.find(port);
125 if (it == table.end()) {
126 set_local_port(port);
127 table.set(port, this);
128 return port;
129 }
130 ++port;
131 if (port > last_ephemeral_port)
132 port = first_ephemeral_port;
133 if (port == first_scan_port)
134 break;
135 }
136 return set_so_error(EADDRINUSE);
137 });
138}
139
140ErrorOr<void> UDPSocket::protocol_bind()
141{
142 return sockets_by_port().with_exclusive([&](auto& table) -> ErrorOr<void> {
143 if (table.contains(local_port()))
144 return set_so_error(EADDRINUSE);
145 table.set(local_port(), this);
146 return {};
147 });
148}
149
150}