src/network/core/tcp_coordinator.cpp

   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 "../../timer/timer_game_calendar.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  */
  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  */
  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         std::unique_ptr<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                 if (!cont) return true;
  73         }
  74
  75         return i != MAX_PACKETS_TO_RECEIVE - 1;
  76 }
  77
  78 /**
  79  * Helper for logging receiving invalid packets.
  80  * @param type The received packet type.
  81  * @return Always false, as it's an error.
  82  */
  83 bool NetworkCoordinatorSocketHandler::ReceiveInvalidPacket(PacketCoordinatorType type)
  84 {
  85         Debug(net, 0, "[tcp/coordinator] Received illegal packet type {}", type);
  86         return false;
  87 }
  88
  89 bool NetworkCoordinatorSocketHandler::Receive_GC_ERROR(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_ERROR); }
  90 bool NetworkCoordinatorSocketHandler::Receive_SERVER_REGISTER(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_SERVER_REGISTER); }
  91 bool NetworkCoordinatorSocketHandler::Receive_GC_REGISTER_ACK(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_REGISTER_ACK); }
  92 bool NetworkCoordinatorSocketHandler::Receive_SERVER_UPDATE(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_SERVER_UPDATE); }
  93 bool NetworkCoordinatorSocketHandler::Receive_CLIENT_LISTING(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_CLIENT_LISTING); }
  94 bool NetworkCoordinatorSocketHandler::Receive_GC_LISTING(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_LISTING); }
  95 bool NetworkCoordinatorSocketHandler::Receive_CLIENT_CONNECT(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_CLIENT_CONNECT); }
  96 bool NetworkCoordinatorSocketHandler::Receive_GC_CONNECTING(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_CONNECTING); }
  97 bool NetworkCoordinatorSocketHandler::Receive_SERCLI_CONNECT_FAILED(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_SERCLI_CONNECT_FAILED); }
  98 bool NetworkCoordinatorSocketHandler::Receive_GC_CONNECT_FAILED(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_CONNECT_FAILED); }
  99 bool NetworkCoordinatorSocketHandler::Receive_CLIENT_CONNECTED(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_CLIENT_CONNECTED); }
 100 bool NetworkCoordinatorSocketHandler::Receive_GC_DIRECT_CONNECT(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_DIRECT_CONNECT); }
 101 bool NetworkCoordinatorSocketHandler::Receive_GC_STUN_REQUEST(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_STUN_REQUEST); }
 102 bool NetworkCoordinatorSocketHandler::Receive_SERCLI_STUN_RESULT(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_SERCLI_STUN_RESULT); }
 103 bool NetworkCoordinatorSocketHandler::Receive_GC_STUN_CONNECT(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_STUN_CONNECT); }
 104 bool NetworkCoordinatorSocketHandler::Receive_GC_NEWGRF_LOOKUP(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_NEWGRF_LOOKUP); }
 105 bool NetworkCoordinatorSocketHandler::Receive_GC_TURN_CONNECT(Packet &) { return this->ReceiveInvalidPacket(PACKET_COORDINATOR_GC_TURN_CONNECT); }