tcp_game.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#ifndef NETWORK_CORE_TCP_GAME_H
#define NETWORK_CORE_TCP_GAME_H
 
#include "os_abstraction.h"
#include "tcp.h"
#include "../network_type.h"
#include "../../core/pool_type.hpp"
#include <chrono>
 
enum PacketGameType : uint8_t {
  /*
   * These first ten packets must remain in this order for backward and forward compatibility
   * between clients that are trying to join directly. These packets can be received and/or sent
   * by the server before the server has processed the 'join' packet from the client.
   */
 
  /* Packets sent by socket accepting code without ever constructing a client socket instance. */
  PACKET_SERVER_FULL,                  
  PACKET_SERVER_BANNED,                
 
  /* Packets used by the client to join and an error message when the revision is wrong. */
  PACKET_CLIENT_JOIN,                  
  PACKET_SERVER_ERROR,                 
 
  /* Unused packet types, formerly used for the pre-game lobby. */
  PACKET_CLIENT_UNUSED,                
  PACKET_SERVER_UNUSED,                
 
  /* Packets used to get the game info. */
  PACKET_SERVER_GAME_INFO,             
  PACKET_CLIENT_GAME_INFO,             
 
  /* A server quitting this game. */
  PACKET_SERVER_NEWGAME,               
  PACKET_SERVER_SHUTDOWN,              
 
  /*
   * Packets after here assume that the client
   * and server are running the same version. As
   * such ordering is unimportant from here on.
   *
   * The following is the remainder of the packets
   * sent as part of authenticating and getting
   * the map and other important data.
   */
 
  /* After the join step, the first perform game authentication and enabling encryption. */
  PACKET_SERVER_AUTH_REQUEST,          
  PACKET_CLIENT_AUTH_RESPONSE,         
  PACKET_SERVER_ENABLE_ENCRYPTION,     
 
  /* After the authentication is done, the next step is identification. */
  PACKET_CLIENT_IDENTIFY,              
 
  /* After the identify step, the next is checking NewGRFs. */
  PACKET_SERVER_CHECK_NEWGRFS,         
  PACKET_CLIENT_NEWGRFS_CHECKED,       
 
  /* The server welcomes the authenticated client and sends information of other clients. */
  PACKET_SERVER_WELCOME,               
  PACKET_SERVER_CLIENT_INFO,           
 
  /* Getting the savegame/map. */
  PACKET_CLIENT_GETMAP,                
  PACKET_SERVER_WAIT,                  
  PACKET_SERVER_MAP_BEGIN,             
  PACKET_SERVER_MAP_SIZE,              
  PACKET_SERVER_MAP_DATA,              
  PACKET_SERVER_MAP_DONE,              
  PACKET_CLIENT_MAP_OK,                
 
  PACKET_SERVER_JOIN,                  
 
  /*
   * At this moment the client has the map and
   * the client is fully authenticated. Now the
   * normal communication starts.
   */
 
  /* Game progress monitoring. */
  PACKET_SERVER_FRAME,                 
  PACKET_CLIENT_ACK,                   
  PACKET_SERVER_SYNC,                  
 
  /* Sending commands around. */
  PACKET_CLIENT_COMMAND,               
  PACKET_SERVER_COMMAND,               
 
  /* Human communication! */
  PACKET_CLIENT_CHAT,                  
  PACKET_SERVER_CHAT,                  
  PACKET_SERVER_EXTERNAL_CHAT,         
 
  /* Remote console. */
  PACKET_CLIENT_RCON,                  
  PACKET_SERVER_RCON,                  
 
  /* Moving a client.*/
  PACKET_CLIENT_MOVE,                  
  PACKET_SERVER_MOVE,                  
 
  /* Configuration updates. */
  PACKET_CLIENT_SET_NAME,              
  PACKET_SERVER_CONFIG_UPDATE,         
 
  /* A client quitting. */
  PACKET_CLIENT_QUIT,                  
  PACKET_SERVER_QUIT,                  
  PACKET_CLIENT_ERROR,                 
  PACKET_SERVER_ERROR_QUIT,            
 
  PACKET_END,                          
};
 
struct CommandPacket;
 
using CommandQueue = std::vector<CommandPacket>;
 
class NetworkGameSocketHandler : public NetworkTCPSocketHandler {
/* TODO: rewrite into a proper class */
private:
  NetworkClientInfo *info;          
  bool is_pending_deletion = false; 
 
protected:
  NetworkRecvStatus ReceiveInvalidPacket(PacketGameType type);
 
  virtual NetworkRecvStatus Receive_SERVER_FULL(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_BANNED(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_JOIN(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_ERROR(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_GAME_INFO(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_GAME_INFO(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_CLIENT_INFO(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_IDENTIFY(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_AUTH_REQUEST(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_AUTH_RESPONSE(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_ENABLE_ENCRYPTION(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_WELCOME(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_GETMAP(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_WAIT(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_MAP_BEGIN(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_MAP_SIZE(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_MAP_DATA(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_MAP_DONE(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_MAP_OK(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_JOIN(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_FRAME(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_SYNC(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_ACK(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_COMMAND(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_COMMAND(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_CHAT(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_CHAT(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_EXTERNAL_CHAT(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_SET_NAME(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_QUIT(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_ERROR(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_QUIT(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_ERROR_QUIT(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_SHUTDOWN(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_NEWGAME(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_RCON(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_RCON(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_CHECK_NEWGRFS(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_NEWGRFS_CHECKED(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_MOVE(Packet &p);
 
  virtual NetworkRecvStatus Receive_CLIENT_MOVE(Packet &p);
 
  virtual NetworkRecvStatus Receive_SERVER_CONFIG_UPDATE(Packet &p);
 
  NetworkRecvStatus HandlePacket(Packet &p);
 
  NetworkGameSocketHandler(SOCKET s);
public:
  ClientID client_id;          
  uint32_t last_frame;           
  uint32_t last_frame_server;    
  CommandQueue incoming_queue; 
  std::chrono::steady_clock::time_point last_packet; 
 
  NetworkRecvStatus CloseConnection(bool error = true) override;
 
  virtual NetworkRecvStatus CloseConnection(NetworkRecvStatus status) = 0;
  virtual ~NetworkGameSocketHandler() = default;
 
  inline void SetInfo(NetworkClientInfo *info)
  {
    assert(info != nullptr && this->info == nullptr);
    this->info = info;
  }
 
  inline NetworkClientInfo *GetInfo() const
  {
    return this->info;
  }
 
  NetworkRecvStatus ReceivePackets();
 
  const char *ReceiveCommand(Packet &p, CommandPacket &cp);
  void SendCommand(Packet &p, const CommandPacket &cp);
 
  bool IsPendingDeletion() const { return this->is_pending_deletion; }
 
  void DeferDeletion();
  static void ProcessDeferredDeletions();
};
 
#endif /* NETWORK_CORE_TCP_GAME_H */