OpenTTD Source: src/network/core/tcp.cpp Source File

OpenTTD Source 14.0-beta3

tcp.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
12 #include "../../stdafx.h"
13 #include "../../debug.h"
14
15 #include "tcp.h"
16
17 #include "../../safeguards.h"
18
23 NetworkTCPSocketHandler::NetworkTCPSocketHandler(SOCKET s) :
24 NetworkSocketHandler(),
25 sock(s), writable(false)
26 {
27 }
28
29 NetworkTCPSocketHandler::~NetworkTCPSocketHandler()
30 {
31 this->CloseSocket();
32 }
33
39 void NetworkTCPSocketHandler::CloseSocket()
40 {
41 if (this->sock != INVALID_SOCKET) closesocket(this->sock);
42 this->sock = INVALID_SOCKET;
43 }
44
51 NetworkRecvStatus NetworkTCPSocketHandler::CloseConnection([[maybe_unused]] bool error)
52 {
53 this->MarkClosed();
54 this->writable = false;
55
56 this->packet_queue.clear();
57 this->packet_recv = nullptr;
58
59 return NETWORK_RECV_STATUS_OKAY;
60 }
61
68 void NetworkTCPSocketHandler::SendPacket(std::unique_ptr<Packet> &&packet)
69 {
70 assert(packet != nullptr);
71
72 packet->PrepareToSend();
73 this->packet_queue.push_back(std::move(packet));
74 }
75
86 SendPacketsState NetworkTCPSocketHandler::SendPackets(bool closing_down)
87 {
88 /* We can not write to this socket!! */
89 if (!this->writable) return SPS_NONE_SENT;
90 if (!this->IsConnected()) return SPS_CLOSED;
91
92 while (!this->packet_queue.empty()) {
93 Packet &p = *this->packet_queue.front();
94 ssize_t res = p.TransferOut<int>(send, this->sock, 0);
95 if (res == -1) {
96 NetworkError err = NetworkError::GetLast();
97 if (!err.WouldBlock()) {
98 /* Something went wrong.. close client! */
99 if (!closing_down) {
100 Debug(net, 0, "Send failed: {}", err.AsString());
101 this->CloseConnection();
102 }
103 return SPS_CLOSED;
104 }
105 return SPS_PARTLY_SENT;
106 }
107 if (res == 0) {
108 /* Client/server has left us :( */
109 if (!closing_down) this->CloseConnection();
110 return SPS_CLOSED;
111 }
112
113 /* Is this packet sent? */
114 if (p.RemainingBytesToTransfer() == 0) {
115 /* Go to the next packet */
116 this->packet_queue.pop_front();
117 } else {
118 return SPS_PARTLY_SENT;
119 }
120 }
121
122 return SPS_ALL_SENT;
123 }
124
129 std::unique_ptr<Packet> NetworkTCPSocketHandler::ReceivePacket()
130 {
131 ssize_t res;
132
133 if (!this->IsConnected()) return nullptr;
134
135 if (this->packet_recv == nullptr) {
136 this->packet_recv = std::make_unique<Packet>(this, TCP_MTU);
137 }
138
139 Packet &p = *this->packet_recv.get();
140
141 /* Read packet size */
142 if (!p.HasPacketSizeData()) {
143 while (p.RemainingBytesToTransfer() != 0) {
144 res = p.TransferIn<int>(recv, this->sock, 0);
145 if (res == -1) {
146 NetworkError err = NetworkError::GetLast();
147 if (!err.WouldBlock()) {
148 /* Something went wrong... */
149 if (!err.IsConnectionReset()) Debug(net, 0, "Recv failed: {}", err.AsString());
150 this->CloseConnection();
151 return nullptr;
152 }
153 /* Connection would block, so stop for now */
154 return nullptr;
155 }
156 if (res == 0) {
157 /* Client/server has left */
158 this->CloseConnection();
159 return nullptr;
160 }
161 }
162
163 /* Parse the size in the received packet and if not valid, close the connection. */
164 if (!p.ParsePacketSize()) {
165 this->CloseConnection();
166 return nullptr;
167 }
168 }
169
170 /* Read rest of packet */
171 while (p.RemainingBytesToTransfer() != 0) {
172 res = p.TransferIn<int>(recv, this->sock, 0);
173 if (res == -1) {
174 NetworkError err = NetworkError::GetLast();
175 if (!err.WouldBlock()) {
176 /* Something went wrong... */
177 if (!err.IsConnectionReset()) Debug(net, 0, "Recv failed: {}", err.AsString());
178 this->CloseConnection();
179 return nullptr;
180 }
181 /* Connection would block */
182 return nullptr;
183 }
184 if (res == 0) {
185 /* Client/server has left */
186 this->CloseConnection();
187 return nullptr;
188 }
189 }
190
191 p.PrepareToRead();
192 return std::move(this->packet_recv);
193 }
194
200 bool NetworkTCPSocketHandler::CanSendReceive()
201 {
202 assert(this->sock != INVALID_SOCKET);
203
204 fd_set read_fd, write_fd;
205 struct timeval tv;
206
207 FD_ZERO(&read_fd);
208 FD_ZERO(&write_fd);
209
210 FD_SET(this->sock, &read_fd);
211 FD_SET(this->sock, &write_fd);
212
213 tv.tv_sec = tv.tv_usec = 0; // don't block at all.
214 if (select(FD_SETSIZE, &read_fd, &write_fd, nullptr, &tv) < 0) return false;
215
216 this->writable = !!FD_ISSET(this->sock, &write_fd);
217 return FD_ISSET(this->sock, &read_fd) != 0;
218 }
NetworkTCPSocketHandler::SendPacket
virtual void SendPacket(std::unique_ptr< Packet > &&packet)
This function puts the packet in the send-queue and it is send as soon as possible.
Definition: tcp.cpp:68
NetworkSocketHandler
SocketHandler for all network sockets in OpenTTD.
Definition: core.h:42
SPS_CLOSED
@ SPS_CLOSED
The connection got closed.
Definition: tcp.h:24
NetworkTCPSocketHandler::IsConnected
bool IsConnected() const
Whether this socket is currently bound to a socket.
Definition: tcp.h:45
Packet::HasPacketSizeData
bool HasPacketSizeData() const
Check whether the packet, given the position of the "write" pointer, has read enough of the packet to...
Definition: packet.cpp:223
NetworkTCPSocketHandler::sock
SOCKET sock
The socket currently connected to.
Definition: tcp.h:38
Packet::TransferOut
ssize_t TransferOut(F transfer_function, D destination, Args &&... args)
Transfer data from the packet to the given function.
Definition: packet.h:136
Packet::ParsePacketSize
bool ParsePacketSize()
Reads the packet size from the raw packet and stores it in the packet->size.
Definition: packet.cpp:244
SPS_ALL_SENT
@ SPS_ALL_SENT
All packets in the queue are sent.
Definition: tcp.h:27
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
NetworkTCPSocketHandler::packet_queue
std::deque< std::unique_ptr< Packet > > packet_queue
Packets that are awaiting delivery. Cannot be std::queue as that does not have a clear() function.
Definition: tcp.h:33
SendPacketsState
SendPacketsState
The states of sending the packets.
Definition: tcp.h:23
Packet::PrepareToRead
void PrepareToRead()
Prepares the packet so it can be read.
Definition: packet.cpp:263
NetworkError::WouldBlock
bool WouldBlock() const
Check whether this error describes that the operation would block.
Definition: os_abstraction.cpp:39
NetworkError::GetLast
static NetworkError GetLast()
Get the last network error.
Definition: os_abstraction.cpp:118
NetworkTCPSocketHandler::packet_recv
std::unique_ptr< Packet > packet_recv
Partially received packet.
Definition: tcp.h:34
NetworkSocketHandler::MarkClosed
void MarkClosed()
Mark the connection as closed.
Definition: core.h:60
NetworkTCPSocketHandler::CloseConnection
virtual NetworkRecvStatus CloseConnection(bool error=true)
This will put this socket handler in a close state.
Definition: tcp.cpp:51
TCP_MTU
static const size_t TCP_MTU
Number of bytes we can pack in a single TCP packet.
Definition: config.h:45
Packet::TransferIn
ssize_t TransferIn(F transfer_function, S source, Args &&... args)
Transfer data from the given function into the packet.
Definition: packet.h:171
Packet
Internal entity of a packet.
Definition: packet.h:42
NetworkTCPSocketHandler::NetworkTCPSocketHandler
NetworkTCPSocketHandler(SOCKET s=INVALID_SOCKET)
Construct a socket handler for a TCP connection.
Definition: tcp.cpp:23
NetworkTCPSocketHandler::writable
bool writable
Can we write to this socket?
Definition: tcp.h:39
SPS_NONE_SENT
@ SPS_NONE_SENT
The buffer is still full, so no (parts of) packets could be sent.
Definition: tcp.h:25
NetworkTCPSocketHandler::SendPackets
SendPacketsState SendPackets(bool closing_down=false)
Sends all the buffered packets out for this client.
Definition: tcp.cpp:86
NetworkTCPSocketHandler::CanSendReceive
bool CanSendReceive()
Check whether this socket can send or receive something.
Definition: tcp.cpp:200
NetworkRecvStatus
NetworkRecvStatus
Status of a network client; reasons why a client has quit.
Definition: core.h:22
tcp.h
NetworkError::IsConnectionReset
bool IsConnectionReset() const
Check whether this error describes a connection reset.
Definition: os_abstraction.cpp:54
NetworkError::AsString
const std::string & AsString() const
Get the string representation of the error message.
Definition: os_abstraction.cpp:80
NetworkError
Abstraction of a network error where all implementation details of the error codes are encapsulated i...
Definition: os_abstraction.h:21
NetworkTCPSocketHandler::ReceivePacket
virtual std::unique_ptr< Packet > ReceivePacket()
Receives a packet for the given client.
Definition: tcp.cpp:129
SPS_PARTLY_SENT
@ SPS_PARTLY_SENT
The packets are partly sent; there are more packets to be sent in the queue.
Definition: tcp.h:26
NETWORK_RECV_STATUS_OKAY
@ NETWORK_RECV_STATUS_OKAY
Everything is okay.
Definition: core.h:23
Packet::RemainingBytesToTransfer
size_t RemainingBytesToTransfer() const
Get the amount of bytes that are still available for the Transfer functions.
Definition: packet.cpp:405
NetworkTCPSocketHandler::CloseSocket
void CloseSocket()
Close the actual socket of the connection.
Definition: tcp.cpp:39