1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/AtomicRefCounted.h>
#include <AK/ByteBuffer.h>
#include <AK/Function.h>
#include <AK/IntrusiveList.h>
#include <AK/MACAddress.h>
#include <AK/Types.h>
#include <Kernel/Bus/PCI/Definitions.h>
#include <Kernel/KBuffer.h>
#include <Kernel/Library/LockWeakPtr.h>
#include <Kernel/Library/LockWeakable.h>
#include <Kernel/Net/ARP.h>
#include <Kernel/Net/EthernetFrameHeader.h>
#include <Kernel/Net/ICMP.h>
#include <Kernel/Net/IPv4.h>
#include <Kernel/UserOrKernelBuffer.h>
namespace Kernel {
class NetworkAdapter;
using NetworkByteBuffer = AK::Detail::ByteBuffer<1500>;
struct PacketWithTimestamp final : public AtomicRefCounted<PacketWithTimestamp> {
PacketWithTimestamp(NonnullOwnPtr<KBuffer> buffer, UnixDateTime timestamp)
: buffer(move(buffer))
, timestamp(timestamp)
{
}
ReadonlyBytes bytes() { return buffer->bytes(); }
NonnullOwnPtr<KBuffer> buffer;
UnixDateTime timestamp;
IntrusiveListNode<PacketWithTimestamp, RefPtr<PacketWithTimestamp>> packet_node;
};
class NetworkingManagement;
class NetworkAdapter
: public AtomicRefCounted<NetworkAdapter>
, public LockWeakable<NetworkAdapter> {
public:
enum class Type {
Loopback,
Ethernet
};
static constexpr i32 LINKSPEED_INVALID = -1;
virtual ~NetworkAdapter();
virtual StringView class_name() const = 0;
virtual Type adapter_type() const = 0;
virtual ErrorOr<void> initialize(Badge<NetworkingManagement>) = 0;
StringView name() const { return m_name->view(); }
MACAddress mac_address() { return m_mac_address; }
IPv4Address ipv4_address() const { return m_ipv4_address; }
IPv4Address ipv4_netmask() const { return m_ipv4_netmask; }
IPv4Address ipv4_broadcast() const { return IPv4Address { (m_ipv4_address.to_u32() & m_ipv4_netmask.to_u32()) | ~m_ipv4_netmask.to_u32() }; }
virtual bool link_up() { return false; }
virtual i32 link_speed()
{
// In Mbit/sec.
return LINKSPEED_INVALID;
}
virtual bool link_full_duplex() { return false; }
void set_ipv4_address(IPv4Address const&);
void set_ipv4_netmask(IPv4Address const&);
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, UnixDateTime& packet_timestamp);
bool has_queued_packets() const { return !m_packet_queue.is_empty(); }
u32 mtu() const { return m_mtu; }
void set_mtu(u32 mtu) { m_mtu = mtu; }
u32 packets_in() const { return m_packets_in; }
u32 bytes_in() const { return m_bytes_in; }
u32 packets_out() const { return m_packets_out; }
u32 bytes_out() const { return m_bytes_out; }
RefPtr<PacketWithTimestamp> acquire_packet_buffer(size_t);
void release_packet_buffer(PacketWithTimestamp&);
constexpr size_t layer3_payload_offset() const { return sizeof(EthernetFrameHeader); }
constexpr size_t ipv4_payload_offset() const { return layer3_payload_offset() + sizeof(IPv4Packet); }
Function<void()> on_receive;
void send_packet(ReadonlyBytes);
protected:
NetworkAdapter(NonnullOwnPtr<KString>);
void set_mac_address(MACAddress const& mac_address) { m_mac_address = mac_address; }
void did_receive(ReadonlyBytes);
virtual void send_raw(ReadonlyBytes) = 0;
private:
MACAddress m_mac_address;
IPv4Address m_ipv4_address;
IPv4Address m_ipv4_netmask;
// FIXME: Make this configurable
static constexpr size_t max_packet_buffers = 1024;
using PacketList = IntrusiveList<&PacketWithTimestamp::packet_node>;
PacketList m_packet_queue;
size_t m_packet_queue_size { 0 };
SpinlockProtected<PacketList, LockRank::None> m_unused_packets {};
NonnullOwnPtr<KString> m_name;
u32 m_packets_in { 0 };
u32 m_bytes_in { 0 };
u32 m_packets_out { 0 };
u32 m_bytes_out { 0 };
u32 m_mtu { 1500 };
};
}
|
