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
|
#pragma once
#include <AK/Function.h>
#include <AK/WeakPtr.h>
#include <Kernel/Net/IPv4Socket.h>
class TCPSocket final : public IPv4Socket {
public:
static void for_each(Function<void(TCPSocket&)>);
static NonnullRefPtr<TCPSocket> create(int protocol);
virtual ~TCPSocket() override;
enum class Direction {
Unspecified,
Outgoing,
Incoming,
Passive,
};
static const char* to_string(Direction direction)
{
switch (direction) {
case Direction::Unspecified:
return "Unspecified";
case Direction::Outgoing:
return "Outgoing";
case Direction::Incoming:
return "Incoming";
case Direction::Passive:
return "Passive";
default:
return "None";
}
}
enum class State {
Closed,
Listen,
SynSent,
SynReceived,
Established,
CloseWait,
LastAck,
FinWait1,
FinWait2,
Closing,
TimeWait,
};
static const char* to_string(State state)
{
switch (state) {
case State::Closed:
return "Closed";
case State::Listen:
return "Listen";
case State::SynSent:
return "SynSent";
case State::SynReceived:
return "SynReceived";
case State::Established:
return "Established";
case State::CloseWait:
return "CloseWait";
case State::LastAck:
return "LastAck";
case State::FinWait1:
return "FinWait1";
case State::FinWait2:
return "FinWait2";
case State::Closing:
return "Closing";
case State::TimeWait:
return "TimeWait";
default:
return "None";
}
}
State state() const { return m_state; }
void set_state(State state);
Direction direction() const { return m_direction; }
void set_ack_number(u32 n) { m_ack_number = n; }
void set_sequence_number(u32 n) { m_sequence_number = n; }
u32 ack_number() const { return m_ack_number; }
u32 sequence_number() const { return m_sequence_number; }
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; }
void send_tcp_packet(u16 flags, const void* = nullptr, int = 0);
void record_incoming_data(int);
static Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>& sockets_by_tuple();
static SocketHandle<TCPSocket> from_tuple(const IPv4SocketTuple& tuple);
static SocketHandle<TCPSocket> from_endpoints(const IPv4Address& local_address, u16 local_port, const IPv4Address& peer_address, u16 peer_port);
SocketHandle<TCPSocket> create_client(const IPv4Address& local_address, u16 local_port, const IPv4Address& peer_address, u16 peer_port);
protected:
void set_direction(Direction direction) { m_direction = direction; }
private:
explicit TCPSocket(int protocol);
virtual const char* class_name() const override { return "TCPSocket"; }
static NetworkOrdered<u16> compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket&, u16 payload_size);
virtual int protocol_receive(const KBuffer&, void* buffer, size_t buffer_size, int flags) override;
virtual int protocol_send(const void*, int) override;
virtual KResult protocol_connect(FileDescription&, ShouldBlock) override;
virtual int protocol_allocate_local_port() override;
virtual bool protocol_is_disconnected() const override;
virtual KResult protocol_bind() override;
virtual KResult protocol_listen() override;
Direction m_direction { Direction::Unspecified };
WeakPtr<NetworkAdapter> m_adapter;
u32 m_sequence_number { 0 };
u32 m_ack_number { 0 };
State m_state { State::Closed };
u32 m_packets_in { 0 };
u32 m_bytes_in { 0 };
u32 m_packets_out { 0 };
u32 m_bytes_out { 0 };
};
|
