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
8 /**
9 * @file tcp_coordinator.cpp Basic functions to receive and send Game Coordinator packets.
10 */
11
12 #include "../../stdafx.h"
13 #include "../../date_func.h"
14 #include "../../debug.h"
15 #include "tcp_coordinator.h"
16
17 #include "../../safeguards.h"
18
19 /**
20 * Handle the given packet, i.e. pass it to the right.
21 * parser receive command.
22 * @param p The packet to handle.
23 * @return True iff we should immediately handle further packets.
24 */
HandlePacket(Packet * p)25 bool NetworkCoordinatorSocketHandler::HandlePacket(Packet *p)
26 {
27 PacketCoordinatorType type = (PacketCoordinatorType)p->Recv_uint8();
28
29 switch (type) {
30 case PACKET_COORDINATOR_GC_ERROR: return this->Receive_GC_ERROR(p);
31 case PACKET_COORDINATOR_SERVER_REGISTER: return this->Receive_SERVER_REGISTER(p);
32 case PACKET_COORDINATOR_GC_REGISTER_ACK: return this->Receive_GC_REGISTER_ACK(p);
33 case PACKET_COORDINATOR_SERVER_UPDATE: return this->Receive_SERVER_UPDATE(p);
34 case PACKET_COORDINATOR_CLIENT_LISTING: return this->Receive_CLIENT_LISTING(p);
35 case PACKET_COORDINATOR_GC_LISTING: return this->Receive_GC_LISTING(p);
36 case PACKET_COORDINATOR_CLIENT_CONNECT: return this->Receive_CLIENT_CONNECT(p);
37 case PACKET_COORDINATOR_GC_CONNECTING: return this->Receive_GC_CONNECTING(p);
38 case PACKET_COORDINATOR_SERCLI_CONNECT_FAILED: return this->Receive_SERCLI_CONNECT_FAILED(p);
39 case PACKET_COORDINATOR_GC_CONNECT_FAILED: return this->Receive_GC_CONNECT_FAILED(p);
40 case PACKET_COORDINATOR_CLIENT_CONNECTED: return this->Receive_CLIENT_CONNECTED(p);
41 case PACKET_COORDINATOR_GC_DIRECT_CONNECT: return this->Receive_GC_DIRECT_CONNECT(p);
42 case PACKET_COORDINATOR_GC_STUN_REQUEST: return this->Receive_GC_STUN_REQUEST(p);
43 case PACKET_COORDINATOR_SERCLI_STUN_RESULT: return this->Receive_SERCLI_STUN_RESULT(p);
44 case PACKET_COORDINATOR_GC_STUN_CONNECT: return this->Receive_GC_STUN_CONNECT(p);
45 case PACKET_COORDINATOR_GC_NEWGRF_LOOKUP: return this->Receive_GC_NEWGRF_LOOKUP(p);
46 case PACKET_COORDINATOR_GC_TURN_CONNECT: return this->Receive_GC_TURN_CONNECT(p);
47
48 default:
49 Debug(net, 0, "[tcp/coordinator] Received invalid packet type {}", type);
50 return false;
51 }
52 }
53
54 /**
55 * Receive a packet at TCP level.
56 * @return Whether at least one packet was received.
57 */
ReceivePackets()58 bool NetworkCoordinatorSocketHandler::ReceivePackets()
59 {
60 /*
61 * We read only a few of the packets. This allows the GUI to update when
62 * a large set of servers is being received. Otherwise the interface
63 * "hangs" while the game is updating the server-list.
64 *
65 * What arbitrary number to choose is the ultimate question though.
66 */
67 Packet *p;
68 static const int MAX_PACKETS_TO_RECEIVE = 42;
69 int i = MAX_PACKETS_TO_RECEIVE;
70 while (--i != 0 && (p = this->ReceivePacket()) != nullptr) {
71 bool cont = this->HandlePacket(p);
72 delete p;
73 if (!cont) return true;
74 }
75
76 return i != MAX_PACKETS_TO_RECEIVE - 1;
77 }
78
79 /**
80 * Helper for logging receiving invalid packets.
81 * @param type The received packet type.
82 * @return Always false, as it's an error.
83 */
ReceiveInvalidPacket(PacketCoordinatorType type)84 bool NetworkCoordinatorSocketHandler::ReceiveInvalidPacket(PacketCoordinatorType type)
85 {
86 Debug(net, 0, "[tcp/coordinator] Received illegal packet type {}", type);
87 return false;
88 }
89
Receive_GC_ERROR(Packet * p)90 bool NetworkCoordinatorSocketHandler::Receive_GC_ERROR(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_ERROR); }
Receive_SERVER_REGISTER(Packet * p)91 bool NetworkCoordinatorSocketHandler::Receive_SERVER_REGISTER(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_SERVER_REGISTER); }
Receive_GC_REGISTER_ACK(Packet * p)92 bool NetworkCoordinatorSocketHandler::Receive_GC_REGISTER_ACK(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_REGISTER_ACK); }
Receive_SERVER_UPDATE(Packet * p)93 bool NetworkCoordinatorSocketHandler::Receive_SERVER_UPDATE(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_SERVER_UPDATE); }
Receive_CLIENT_LISTING(Packet * p)94 bool NetworkCoordinatorSocketHandler::Receive_CLIENT_LISTING(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_CLIENT_LISTING); }
Receive_GC_LISTING(Packet * p)95 bool NetworkCoordinatorSocketHandler::Receive_GC_LISTING(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_LISTING); }
Receive_CLIENT_CONNECT(Packet * p)96 bool NetworkCoordinatorSocketHandler::Receive_CLIENT_CONNECT(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_CLIENT_CONNECT); }
Receive_GC_CONNECTING(Packet * p)97 bool NetworkCoordinatorSocketHandler::Receive_GC_CONNECTING(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_CONNECTING); }
Receive_SERCLI_CONNECT_FAILED(Packet * p)98 bool NetworkCoordinatorSocketHandler::Receive_SERCLI_CONNECT_FAILED(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_SERCLI_CONNECT_FAILED); }
Receive_GC_CONNECT_FAILED(Packet * p)99 bool NetworkCoordinatorSocketHandler::Receive_GC_CONNECT_FAILED(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_CONNECT_FAILED); }
Receive_CLIENT_CONNECTED(Packet * p)100 bool NetworkCoordinatorSocketHandler::Receive_CLIENT_CONNECTED(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_CLIENT_CONNECTED); }
Receive_GC_DIRECT_CONNECT(Packet * p)101 bool NetworkCoordinatorSocketHandler::Receive_GC_DIRECT_CONNECT(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_DIRECT_CONNECT); }
Receive_GC_STUN_REQUEST(Packet * p)102 bool NetworkCoordinatorSocketHandler::Receive_GC_STUN_REQUEST(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_STUN_REQUEST); }
Receive_SERCLI_STUN_RESULT(Packet * p)103 bool NetworkCoordinatorSocketHandler::Receive_SERCLI_STUN_RESULT(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_SERCLI_STUN_RESULT); }
Receive_GC_STUN_CONNECT(Packet * p)104 bool NetworkCoordinatorSocketHandler::Receive_GC_STUN_CONNECT(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_STUN_CONNECT); }
Receive_GC_NEWGRF_LOOKUP(Packet * p)105 bool NetworkCoordinatorSocketHandler::Receive_GC_NEWGRF_LOOKUP(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_NEWGRF_LOOKUP); }
Receive_GC_TURN_CONNECT(Packet * p)106 bool NetworkCoordinatorSocketHandler::Receive_GC_TURN_CONNECT(Packet *p) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_TURN_CONNECT); }
107