jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this
9 * list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
22 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#include <AK/HashTable.h>
28#include <AK/StringBuilder.h>
29#include <Kernel/Heap/kmalloc.h>
30#include <Kernel/Lock.h>
31#include <Kernel/Net/EtherType.h>
32#include <Kernel/Net/EthernetFrameHeader.h>
33#include <Kernel/Net/LoopbackAdapter.h>
34#include <Kernel/Net/NetworkAdapter.h>
35#include <LibBareMetal/StdLib.h>
36
37namespace Kernel {
38
39static Lockable<HashTable<NetworkAdapter*>>& all_adapters()
40{
41 static Lockable<HashTable<NetworkAdapter*>>* table;
42 if (!table)
43 table = new Lockable<HashTable<NetworkAdapter*>>;
44 return *table;
45}
46
47void NetworkAdapter::for_each(Function<void(NetworkAdapter&)> callback)
48{
49 LOCKER(all_adapters().lock());
50 for (auto& it : all_adapters().resource())
51 callback(*it);
52}
53
54RefPtr<NetworkAdapter> NetworkAdapter::from_ipv4_address(const IPv4Address& address)
55{
56 LOCKER(all_adapters().lock());
57 for (auto* adapter : all_adapters().resource()) {
58 if (adapter->ipv4_address() == address)
59 return adapter;
60 }
61 if (address[0] == 127)
62 return LoopbackAdapter::the();
63 return nullptr;
64}
65
66RefPtr<NetworkAdapter> NetworkAdapter::lookup_by_name(const StringView& name)
67{
68 NetworkAdapter* found_adapter = nullptr;
69 for_each([&](auto& adapter) {
70 if (adapter.name() == name)
71 found_adapter = &adapter;
72 });
73 return found_adapter;
74}
75
76NetworkAdapter::NetworkAdapter()
77{
78 // FIXME: I wanna lock :(
79 all_adapters().resource().set(this);
80}
81
82NetworkAdapter::~NetworkAdapter()
83{
84 // FIXME: I wanna lock :(
85 all_adapters().resource().remove(this);
86}
87
88void NetworkAdapter::send(const MACAddress& destination, const ARPPacket& packet)
89{
90 int size_in_bytes = sizeof(EthernetFrameHeader) + sizeof(ARPPacket);
91 auto buffer = ByteBuffer::create_zeroed(size_in_bytes);
92 auto* eth = (EthernetFrameHeader*)buffer.data();
93 eth->set_source(mac_address());
94 eth->set_destination(destination);
95 eth->set_ether_type(EtherType::ARP);
96 m_packets_out++;
97 m_bytes_out += size_in_bytes;
98 memcpy(eth->payload(), &packet, sizeof(ARPPacket));
99 send_raw((const u8*)eth, size_in_bytes);
100}
101
102void NetworkAdapter::send_ipv4(const MACAddress& destination_mac, const IPv4Address& destination_ipv4, IPv4Protocol protocol, const u8* payload, size_t payload_size, u8 ttl)
103{
104 size_t ipv4_packet_size = sizeof(IPv4Packet) + payload_size;
105 if (ipv4_packet_size > mtu()) {
106 // FIXME: Implement IP fragmentation.
107 ASSERT_NOT_REACHED();
108 }
109
110 size_t ethernet_frame_size = sizeof(EthernetFrameHeader) + sizeof(IPv4Packet) + payload_size;
111 auto buffer = ByteBuffer::create_zeroed(ethernet_frame_size);
112 auto& eth = *(EthernetFrameHeader*)buffer.data();
113 eth.set_source(mac_address());
114 eth.set_destination(destination_mac);
115 eth.set_ether_type(EtherType::IPv4);
116 auto& ipv4 = *(IPv4Packet*)eth.payload();
117 ipv4.set_version(4);
118 ipv4.set_internet_header_length(5);
119 ipv4.set_source(ipv4_address());
120 ipv4.set_destination(destination_ipv4);
121 ipv4.set_protocol((u8)protocol);
122 ipv4.set_length(sizeof(IPv4Packet) + payload_size);
123 ipv4.set_ident(1);
124 ipv4.set_ttl(ttl);
125 ipv4.set_checksum(ipv4.compute_checksum());
126 m_packets_out++;
127 m_bytes_out += ethernet_frame_size;
128 memcpy(ipv4.payload(), payload, payload_size);
129 send_raw((const u8*)ð, ethernet_frame_size);
130}
131
132void NetworkAdapter::did_receive(const u8* data, size_t length)
133{
134 InterruptDisabler disabler;
135 m_packets_in++;
136 m_bytes_in += length;
137
138 Optional<KBuffer> buffer;
139
140 if (m_unused_packet_buffers.is_empty()) {
141 buffer = KBuffer::copy(data, length);
142 } else {
143 buffer = m_unused_packet_buffers.take_first();
144 --m_unused_packet_buffers_count;
145 if (length <= buffer.value().size()) {
146 memcpy(buffer.value().data(), data, length);
147 buffer.value().set_size(length);
148 } else {
149 buffer = KBuffer::copy(data, length);
150 }
151 }
152
153 m_packet_queue.append(buffer.value());
154
155 if (on_receive)
156 on_receive();
157}
158
159size_t NetworkAdapter::dequeue_packet(u8* buffer, size_t buffer_size)
160{
161 InterruptDisabler disabler;
162 if (m_packet_queue.is_empty())
163 return 0;
164 auto packet = m_packet_queue.take_first();
165 size_t packet_size = packet.size();
166 ASSERT(packet_size <= buffer_size);
167 memcpy(buffer, packet.data(), packet_size);
168 if (m_unused_packet_buffers_count < 100) {
169 m_unused_packet_buffers.append(packet);
170 ++m_unused_packet_buffers_count;
171 }
172 return packet_size;
173}
174
175void NetworkAdapter::set_ipv4_address(const IPv4Address& address)
176{
177 m_ipv4_address = address;
178}
179
180void NetworkAdapter::set_ipv4_netmask(const IPv4Address& netmask)
181{
182 m_ipv4_netmask = netmask;
183}
184
185void NetworkAdapter::set_ipv4_gateway(const IPv4Address& gateway)
186{
187 m_ipv4_gateway = gateway;
188}
189
190void NetworkAdapter::set_interface_name(const StringView& basename)
191{
192 // FIXME: Find a unique name for this interface, starting with $basename.
193 StringBuilder builder;
194 builder.append(basename);
195 builder.append('0');
196 m_name = builder.to_string();
197}
198
199}