From 9acfa96cb32bc92f87ed8e45be6135b06dcb1093 Mon Sep 17 00:00:00 2001 From: Rubidium Date: Sat, 17 Jan 2026 09:17:03 +0100 Subject: [PATCH] Codechange: use scoped enum for PacketGameType --- src/network/core/tcp_game.cpp | 168 +++++++++++++++--------------- src/network/core/tcp_game.h | 184 +++++++++++++++++---------------- src/network/network_client.cpp | 128 +++++++++++------------ src/network/network_client.h | 52 +++++----- src/network/network_query.cpp | 18 ++-- src/network/network_query.h | 8 +- src/network/network_server.cpp | 120 ++++++++++----------- src/network/network_server.h | 32 +++--- 8 files changed, 356 insertions(+), 354 deletions(-) diff --git a/src/network/core/tcp_game.cpp b/src/network/core/tcp_game.cpp index a931401139..424893c366 100644 --- a/src/network/core/tcp_game.cpp +++ b/src/network/core/tcp_game.cpp @@ -63,48 +63,48 @@ NetworkRecvStatus NetworkGameSocketHandler::HandlePacket(Packet &p) this->last_packet = std::chrono::steady_clock::now(); switch (type) { - case PACKET_SERVER_FULL: return this->Receive_SERVER_FULL(p); - case PACKET_SERVER_BANNED: return this->Receive_SERVER_BANNED(p); - case PACKET_CLIENT_JOIN: return this->Receive_CLIENT_JOIN(p); - case PACKET_SERVER_ERROR: return this->Receive_SERVER_ERROR(p); - case PACKET_CLIENT_GAME_INFO: return this->Receive_CLIENT_GAME_INFO(p); - case PACKET_SERVER_GAME_INFO: return this->Receive_SERVER_GAME_INFO(p); - case PACKET_SERVER_CLIENT_INFO: return this->Receive_SERVER_CLIENT_INFO(p); - case PACKET_CLIENT_IDENTIFY: return this->Receive_CLIENT_IDENTIFY(p); - case PACKET_SERVER_AUTH_REQUEST: return this->Receive_SERVER_AUTH_REQUEST(p); - case PACKET_CLIENT_AUTH_RESPONSE: return this->Receive_CLIENT_AUTH_RESPONSE(p); - case PACKET_SERVER_ENABLE_ENCRYPTION: return this->Receive_SERVER_ENABLE_ENCRYPTION(p); - case PACKET_SERVER_WELCOME: return this->Receive_SERVER_WELCOME(p); - case PACKET_CLIENT_GETMAP: return this->Receive_CLIENT_GETMAP(p); - case PACKET_SERVER_WAIT: return this->Receive_SERVER_WAIT(p); - case PACKET_SERVER_MAP_BEGIN: return this->Receive_SERVER_MAP_BEGIN(p); - case PACKET_SERVER_MAP_SIZE: return this->Receive_SERVER_MAP_SIZE(p); - case PACKET_SERVER_MAP_DATA: return this->Receive_SERVER_MAP_DATA(p); - case PACKET_SERVER_MAP_DONE: return this->Receive_SERVER_MAP_DONE(p); - case PACKET_CLIENT_MAP_OK: return this->Receive_CLIENT_MAP_OK(p); - case PACKET_SERVER_JOIN: return this->Receive_SERVER_JOIN(p); - case PACKET_SERVER_FRAME: return this->Receive_SERVER_FRAME(p); - case PACKET_SERVER_SYNC: return this->Receive_SERVER_SYNC(p); - case PACKET_CLIENT_ACK: return this->Receive_CLIENT_ACK(p); - case PACKET_CLIENT_COMMAND: return this->Receive_CLIENT_COMMAND(p); - case PACKET_SERVER_COMMAND: return this->Receive_SERVER_COMMAND(p); - case PACKET_CLIENT_CHAT: return this->Receive_CLIENT_CHAT(p); - case PACKET_SERVER_CHAT: return this->Receive_SERVER_CHAT(p); - case PACKET_SERVER_EXTERNAL_CHAT: return this->Receive_SERVER_EXTERNAL_CHAT(p); - case PACKET_CLIENT_SET_NAME: return this->Receive_CLIENT_SET_NAME(p); - case PACKET_CLIENT_QUIT: return this->Receive_CLIENT_QUIT(p); - case PACKET_CLIENT_ERROR: return this->Receive_CLIENT_ERROR(p); - case PACKET_SERVER_QUIT: return this->Receive_SERVER_QUIT(p); - case PACKET_SERVER_ERROR_QUIT: return this->Receive_SERVER_ERROR_QUIT(p); - case PACKET_SERVER_SHUTDOWN: return this->Receive_SERVER_SHUTDOWN(p); - case PACKET_SERVER_NEWGAME: return this->Receive_SERVER_NEWGAME(p); - case PACKET_SERVER_RCON: return this->Receive_SERVER_RCON(p); - case PACKET_CLIENT_RCON: return this->Receive_CLIENT_RCON(p); - case PACKET_SERVER_CHECK_NEWGRFS: return this->Receive_SERVER_CHECK_NEWGRFS(p); - case PACKET_CLIENT_NEWGRFS_CHECKED: return this->Receive_CLIENT_NEWGRFS_CHECKED(p); - case PACKET_SERVER_MOVE: return this->Receive_SERVER_MOVE(p); - case PACKET_CLIENT_MOVE: return this->Receive_CLIENT_MOVE(p); - case PACKET_SERVER_CONFIG_UPDATE: return this->Receive_SERVER_CONFIG_UPDATE(p); + case PacketGameType::ServerFull: return this->ReceiveServerFull(p); + case PacketGameType::ServerBanned: return this->ReceiveServerBanned(p); + case PacketGameType::ClientJoin: return this->ReceiveClientJoin(p); + case PacketGameType::ServerError: return this->ReceiveServerError(p); + case PacketGameType::ClientGameInfo: return this->ReceiveClientGameInfo(p); + case PacketGameType::ServerGameInfo: return this->ReceiveServerGameInfo(p); + case PacketGameType::ServerClientInfo: return this->ReceiveServerClientInfo(p); + case PacketGameType::ClientIdentify: return this->ReceiveClientIdentify(p); + case PacketGameType::ServerAuthenticationRequest: return this->ReceiveServerAuthenticationRequest(p); + case PacketGameType::ClientAuthenticationResponse: return this->ReceiveClientAuthenticationResponse(p); + case PacketGameType::ServerEnableEncryption: return this->ReceiveServerEnableEncryption(p); + case PacketGameType::ServerWelcome: return this->ReceiveServerWelcome(p); + case PacketGameType::ClientGetMap: return this->ReceiveClientGetMap(p); + case PacketGameType::ServerWaitForMap: return this->ReceiveServerWaitForMap(p); + case PacketGameType::ServerMapBegin: return this->ReceiveServerMapBegin(p); + case PacketGameType::ServerMapSize: return this->ReceiveServerMapSize(p); + case PacketGameType::ServerMapData: return this->ReceiveServerMapData(p); + case PacketGameType::ServerMapDone: return this->ReceiveServerMapDone(p); + case PacketGameType::ClientMapOk: return this->ReceiveClientMapOk(p); + case PacketGameType::ServerClientJoined: return this->ReceiveServerClientJoined(p); + case PacketGameType::ServerFrame: return this->ReceiveServerFrame(p); + case PacketGameType::ServerSync: return this->ReceiveServerSync(p); + case PacketGameType::ClientAck: return this->ReceiveClientAck(p); + case PacketGameType::ClientCommand: return this->ReceiveClientCommand(p); + case PacketGameType::ServerCommand: return this->ReceiveServerCommand(p); + case PacketGameType::ClientChat: return this->ReceiveClientChat(p); + case PacketGameType::ServerChat: return this->ReceiveServerChat(p); + case PacketGameType::ServerExternalChat: return this->ReceiveServerExternalChat(p); + case PacketGameType::ClientSetName: return this->ReceiveClientSetName(p); + case PacketGameType::ClientQuit: return this->ReceiveClientQuit(p); + case PacketGameType::ClientError: return this->ReceiveClientError(p); + case PacketGameType::ServerQuit: return this->ReceiveServerQuit(p); + case PacketGameType::ServerErrorQuit: return this->ReceiveServerErrorQuit(p); + case PacketGameType::ServerShutdown: return this->ReceiveServerShutdown(p); + case PacketGameType::ServerNewGame: return this->ReceiveServerNewGame(p); + case PacketGameType::ServerRemoteConsoleCommand: return this->ReceiveServerRemoteConsoleCommand(p); + case PacketGameType::ClientRemoteConsoleCommand: return this->ReceiveClientRemoteConsoleCommand(p); + case PacketGameType::ServerCheckNewGRFs: return this->ReceiveServerCheckNewGRFs(p); + case PacketGameType::ClientNewGRFsChecked: return this->ReceiveClientNewGRFsChecked(p); + case PacketGameType::ServerMove: return this->ReceiveServerMove(p); + case PacketGameType::ClientMove: return this->ReceiveClientMove(p); + case PacketGameType::ServerConfigurationUpdate: return this->ReceiveServerConfigurationUpdate(p); default: Debug(net, 0, "[tcp/game] Received invalid packet type {} from client {}", type, this->client_id); @@ -142,48 +142,48 @@ NetworkRecvStatus NetworkGameSocketHandler::ReceiveInvalidPacket(PacketGameType return NETWORK_RECV_STATUS_MALFORMED_PACKET; } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_FULL(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_FULL); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_BANNED(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_BANNED); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_JOIN(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_JOIN); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_ERROR(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_ERROR); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_GAME_INFO(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_GAME_INFO); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_GAME_INFO(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_GAME_INFO); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_CLIENT_INFO(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_CLIENT_INFO); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_IDENTIFY(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_IDENTIFY); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_AUTH_REQUEST(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_AUTH_REQUEST); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_AUTH_RESPONSE(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_AUTH_RESPONSE); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_ENABLE_ENCRYPTION(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_ENABLE_ENCRYPTION); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_WELCOME(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_WELCOME); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_GETMAP(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_GETMAP); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_WAIT(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_WAIT); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_MAP_BEGIN(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_MAP_BEGIN); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_MAP_SIZE(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_MAP_SIZE); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_MAP_DATA(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_MAP_DATA); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_MAP_DONE(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_MAP_DONE); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_MAP_OK(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_MAP_OK); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_JOIN(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_JOIN); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_FRAME(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_FRAME); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_SYNC(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_SYNC); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_ACK(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_ACK); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_COMMAND(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_COMMAND); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_COMMAND(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_COMMAND); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_CHAT(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_CHAT); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_CHAT(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_CHAT); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_EXTERNAL_CHAT(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_EXTERNAL_CHAT); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_SET_NAME(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_SET_NAME); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_QUIT(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_QUIT); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_ERROR(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_ERROR); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_QUIT(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_QUIT); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_ERROR_QUIT(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_ERROR_QUIT); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_SHUTDOWN(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_SHUTDOWN); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_NEWGAME(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_NEWGAME); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_RCON(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_RCON); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_RCON(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_RCON); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_CHECK_NEWGRFS(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_CHECK_NEWGRFS); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_NEWGRFS_CHECKED(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_NEWGRFS_CHECKED); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_MOVE(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_MOVE); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_CLIENT_MOVE(Packet &) { return this->ReceiveInvalidPacket(PACKET_CLIENT_MOVE); } -NetworkRecvStatus NetworkGameSocketHandler::Receive_SERVER_CONFIG_UPDATE(Packet &) { return this->ReceiveInvalidPacket(PACKET_SERVER_CONFIG_UPDATE); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerFull(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerFull); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerBanned(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerBanned); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientJoin(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientJoin); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerError(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerError); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientGameInfo(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientGameInfo); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerGameInfo(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerGameInfo); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerClientInfo(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerClientInfo); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientIdentify(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientIdentify); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerAuthenticationRequest(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerAuthenticationRequest); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientAuthenticationResponse(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientAuthenticationResponse); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerEnableEncryption(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerEnableEncryption); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerWelcome(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerWelcome); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientGetMap(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientGetMap); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerWaitForMap(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerWaitForMap); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerMapBegin(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerMapBegin); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerMapSize(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerMapSize); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerMapData(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerMapData); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerMapDone(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerMapDone); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientMapOk(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientMapOk); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerClientJoined(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerClientJoined); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerFrame(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerFrame); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerSync(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerSync); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientAck(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientAck); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientCommand(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientCommand); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerCommand(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerCommand); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientChat(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientChat); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerChat(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerChat); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerExternalChat(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerExternalChat); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientSetName(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientSetName); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientQuit(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientQuit); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientError(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientError); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerQuit(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerQuit); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerErrorQuit(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerErrorQuit); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerShutdown(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerShutdown); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerNewGame(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerNewGame); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerRemoteConsoleCommand(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerRemoteConsoleCommand); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientRemoteConsoleCommand(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientRemoteConsoleCommand); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerCheckNewGRFs(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerCheckNewGRFs); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientNewGRFsChecked(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientNewGRFsChecked); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerMove(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerMove); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveClientMove(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ClientMove); } +NetworkRecvStatus NetworkGameSocketHandler::ReceiveServerConfigurationUpdate(Packet &) { return this->ReceiveInvalidPacket(PacketGameType::ServerConfigurationUpdate); } /** Mark this socket handler for deletion, once iterating the socket handlers is done. */ void NetworkGameSocketHandler::DeferDeletion() diff --git a/src/network/core/tcp_game.h b/src/network/core/tcp_game.h index 0ce19619b0..fe472910ba 100644 --- a/src/network/core/tcp_game.h +++ b/src/network/core/tcp_game.h @@ -19,7 +19,7 @@ * Enum with all types of TCP packets. * For the exact meaning, look at #NetworkGameSocketHandler. */ -enum PacketGameType : uint8_t { +enum class 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 @@ -27,24 +27,24 @@ enum PacketGameType : uint8_t { */ /* Packets sent by socket accepting code without ever constructing a client socket instance. */ - PACKET_SERVER_FULL, ///< The server is full and has no place for you. - PACKET_SERVER_BANNED, ///< The server has banned you. + ServerFull, ///< The server is full and has no place for you. + ServerBanned, ///< The server has banned you. /* Packets used by the client to join and an error message when the revision is wrong. */ - PACKET_CLIENT_JOIN, ///< The client telling the server it wants to join. - PACKET_SERVER_ERROR, ///< Server sending an error message to the client. + ClientJoin, ///< The client telling the server it wants to join. + ServerError, ///< Server sending an error message to the client. /* Unused packet types, formerly used for the pre-game lobby. */ - PACKET_CLIENT_UNUSED, ///< Unused. - PACKET_SERVER_UNUSED, ///< Unused. + ClientUnused, ///< Unused. + ServerUnused, ///< Unused. /* Packets used to get the game info. */ - PACKET_SERVER_GAME_INFO, ///< Information about the server. - PACKET_CLIENT_GAME_INFO, ///< Request information about the server. + ServerGameInfo, ///< Information about the server. + ClientGameInfo, ///< Request information about the server. /* A server quitting this game. */ - PACKET_SERVER_NEWGAME, ///< The server is preparing to start a new game. - PACKET_SERVER_SHUTDOWN, ///< The server is shutting down. + ServerNewGame, ///< The server is preparing to start a new game. + ServerShutdown, ///< The server is shutting down. /* * Packets after here assume that the client @@ -57,31 +57,31 @@ enum PacketGameType : uint8_t { */ /* After the join step, the first perform game authentication and enabling encryption. */ - PACKET_SERVER_AUTH_REQUEST, ///< The server requests the client to authenticate using a number of methods. - PACKET_CLIENT_AUTH_RESPONSE, ///< The client responds to the authentication request. - PACKET_SERVER_ENABLE_ENCRYPTION, ///< The server tells that authentication has completed and requests to enable encryption with the keys of the last \c PACKET_CLIENT_AUTH_RESPONSE. + ServerAuthenticationRequest, ///< The server requests the client to authenticate using a number of methods. + ClientAuthenticationResponse, ///< The client responds to the authentication request. + ServerEnableEncryption, ///< The server tells that authentication has completed and requests to enable encryption with the keys of the last \c PacketGameType::ClientAuthenticationResponse. /* After the authentication is done, the next step is identification. */ - PACKET_CLIENT_IDENTIFY, ///< Client telling the server the client's name and requested company. + ClientIdentify, ///< Client telling the server the client's name and requested company. /* After the identify step, the next is checking NewGRFs. */ - PACKET_SERVER_CHECK_NEWGRFS, ///< Server sends NewGRF IDs and MD5 checksums for the client to check. - PACKET_CLIENT_NEWGRFS_CHECKED, ///< Client acknowledges that it has all required NewGRFs. + ServerCheckNewGRFs, ///< Server sends NewGRF IDs and MD5 checksums for the client to check. + ClientNewGRFsChecked, ///< Client acknowledges that it has all required NewGRFs. /* The server welcomes the authenticated client and sends information of other clients. */ - PACKET_SERVER_WELCOME, ///< Server welcomes you and gives you your #ClientID. - PACKET_SERVER_CLIENT_INFO, ///< Server sends you information about a client. + ServerWelcome, ///< Server welcomes you and gives you your #ClientID. + ServerClientInfo, ///< Server sends you information about a client. /* Getting the savegame/map. */ - PACKET_CLIENT_GETMAP, ///< Client requests the actual map. - PACKET_SERVER_WAIT, ///< Server tells the client there are some people waiting for the map as well. - PACKET_SERVER_MAP_BEGIN, ///< Server tells the client that it is beginning to send the map. - PACKET_SERVER_MAP_SIZE, ///< Server tells the client what the (compressed) size of the map is. - PACKET_SERVER_MAP_DATA, ///< Server sends bits of the map to the client. - PACKET_SERVER_MAP_DONE, ///< Server tells it has just sent the last bits of the map to the client. - PACKET_CLIENT_MAP_OK, ///< Client tells the server that it received the whole map. + ClientGetMap, ///< Client requests the actual map. + ServerWaitForMap, ///< Server tells the client there are some people waiting for the map as well. + ServerMapBegin, ///< Server tells the client that it is beginning to send the map. + ServerMapSize, ///< Server tells the client what the (compressed) size of the map is. + ServerMapData, ///< Server sends bits of the map to the client. + ServerMapDone, ///< Server tells it has just sent the last bits of the map to the client. + ClientMapOk, ///< Client tells the server that it received the whole map. - PACKET_SERVER_JOIN, ///< Tells clients that a new client has joined. + ServerClientJoined, ///< Tells clients that a new client has joined. /* * At this moment the client has the map and @@ -90,38 +90,40 @@ enum PacketGameType : uint8_t { */ /* Game progress monitoring. */ - PACKET_SERVER_FRAME, ///< Server tells the client what frame it is in, and thus to where the client may progress. - PACKET_CLIENT_ACK, ///< The client tells the server which frame it has executed. - PACKET_SERVER_SYNC, ///< Server tells the client what the random state should be. + ServerFrame, ///< Server tells the client what frame it is in, and thus to where the client may progress. + ClientAck, ///< The client tells the server which frame it has executed. + ServerSync, ///< Server tells the client what the random state should be. /* Sending commands around. */ - PACKET_CLIENT_COMMAND, ///< Client executed a command and sends it to the server. - PACKET_SERVER_COMMAND, ///< Server distributes a command to (all) the clients. + ClientCommand, ///< Client executed a command and sends it to the server. + ServerCommand, ///< Server distributes a command to (all) the clients. /* Human communication! */ - PACKET_CLIENT_CHAT, ///< Client said something that should be distributed. - PACKET_SERVER_CHAT, ///< Server distributing the message of a client (or itself). - PACKET_SERVER_EXTERNAL_CHAT, ///< Server distributing the message from external source. + ClientChat, ///< Client said something that should be distributed. + ServerChat, ///< Server distributing the message of a client (or itself). + ServerExternalChat, ///< Server distributing the message from external source. /* Remote console. */ - PACKET_CLIENT_RCON, ///< Client asks the server to execute some command. - PACKET_SERVER_RCON, ///< Response of the executed command on the server. + ClientRemoteConsoleCommand, ///< Client asks the server to execute some command. + ServerRemoteConsoleCommand, ///< Response of the executed command on the server. /* Moving a client.*/ - PACKET_CLIENT_MOVE, ///< A client would like to be moved to another company. - PACKET_SERVER_MOVE, ///< Server tells everyone that someone is moved to another company. + ClientMove, ///< A client would like to be moved to another company. + ServerMove, ///< Server tells everyone that someone is moved to another company. /* Configuration updates. */ - PACKET_CLIENT_SET_NAME, ///< A client changes its name. - PACKET_SERVER_CONFIG_UPDATE, ///< Some network configuration important to the client changed. + ClientSetName, ///< A client changes its name. + ServerConfigurationUpdate, ///< Some network configuration important to the client changed. /* A client quitting. */ - PACKET_CLIENT_QUIT, ///< A client tells the server it is going to quit. - PACKET_SERVER_QUIT, ///< A server tells that a client has quit. - PACKET_CLIENT_ERROR, ///< A client reports an error to the server. - PACKET_SERVER_ERROR_QUIT, ///< A server tells that a client has hit an error and did quit. - - PACKET_END, ///< Must ALWAYS be on the end of this list!! (period) + ClientQuit, ///< A client tells the server it is going to quit. + ServerQuit, ///< A server tells that a client has quit. + ClientError, ///< A client reports an error to the server. + ServerErrorQuit, ///< A server tells that a client has hit an error and did quit. +}; +/** Mark PacketGameType as PacketType. */ +template <> struct IsEnumPacketType { + static constexpr bool value = true; ///< This is an enumeration of a PacketType. }; /** Packet that wraps a command */ @@ -149,14 +151,14 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_FULL(Packet &p); + virtual NetworkRecvStatus ReceiveServerFull(Packet &p); /** * Notification that the client trying to join is banned. * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_BANNED(Packet &p); + virtual NetworkRecvStatus ReceiveServerBanned(Packet &p); /** * Try to join the server: @@ -170,7 +172,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_JOIN(Packet &p); + virtual NetworkRecvStatus ReceiveClientJoin(Packet &p); /** * The client made an error: @@ -178,14 +180,14 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_ERROR(Packet &p); + virtual NetworkRecvStatus ReceiveServerError(Packet &p); /** * Request game information. * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_GAME_INFO(Packet &p); + virtual NetworkRecvStatus ReceiveClientGameInfo(Packet &p); /** * Sends information about the game. @@ -193,7 +195,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_GAME_INFO(Packet &p); + virtual NetworkRecvStatus ReceiveServerGameInfo(Packet &p); /** * Send information about a client: @@ -204,7 +206,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_CLIENT_INFO(Packet &p); + virtual NetworkRecvStatus ReceiveServerClientInfo(Packet &p); /** * The client tells the server about the identity of the client: @@ -213,7 +215,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_IDENTIFY(Packet &p); + virtual NetworkRecvStatus ReceiveClientIdentify(Packet &p); /** * Indication to the client that it needs to authenticate: @@ -223,7 +225,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_AUTH_REQUEST(Packet &p); + virtual NetworkRecvStatus ReceiveServerAuthenticationRequest(Packet &p); /** * Send the response to the authentication request: @@ -233,7 +235,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_AUTH_RESPONSE(Packet &p); + virtual NetworkRecvStatus ReceiveClientAuthenticationResponse(Packet &p); /** * Indication to the client that authentication is complete and encryption has to be used from here on forward. @@ -242,7 +244,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_ENABLE_ENCRYPTION(Packet &p); + virtual NetworkRecvStatus ReceiveServerEnableEncryption(Packet &p); /** * The client is joined and ready to receive their map: @@ -250,14 +252,14 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_WELCOME(Packet &p); + virtual NetworkRecvStatus ReceiveServerWelcome(Packet &p); /** * Request the map from the server. * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_GETMAP(Packet &p); + virtual NetworkRecvStatus ReceiveClientGetMap(Packet &p); /** * Notification that another client is currently receiving the map: @@ -265,7 +267,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_WAIT(Packet &p); + virtual NetworkRecvStatus ReceiveServerWaitForMap(Packet &p); /** * Sends that the server will begin with sending the map to the client: @@ -273,7 +275,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_MAP_BEGIN(Packet &p); + virtual NetworkRecvStatus ReceiveServerMapBegin(Packet &p); /** * Sends the size of the map to the client. @@ -281,7 +283,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_MAP_SIZE(Packet &p); + virtual NetworkRecvStatus ReceiveServerMapSize(Packet &p); /** * Sends the data of the map to the client: @@ -289,29 +291,29 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_MAP_DATA(Packet &p); + virtual NetworkRecvStatus ReceiveServerMapData(Packet &p); /** * Sends that all data of the map are sent to the client: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_MAP_DONE(Packet &p); + virtual NetworkRecvStatus ReceiveServerMapDone(Packet &p); /** * Tell the server that we are done receiving/loading the map. * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_MAP_OK(Packet &p); + virtual NetworkRecvStatus ReceiveClientMapOk(Packet &p); /** - * A client joined (PACKET_CLIENT_MAP_OK), what usually directly follows is a PACKET_SERVER_CLIENT_INFO: + * A client joined (PacketGameType::ClientMapOk), what usually directly follows is a PacketGameType::ServerClientInfo: * uint32_t ID of the client that just joined the game. * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_JOIN(Packet &p); + virtual NetworkRecvStatus ReceiveServerClientJoined(Packet &p); /** * Sends the current frame counter to the client: @@ -323,7 +325,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_FRAME(Packet &p); + virtual NetworkRecvStatus ReceiveServerFrame(Packet &p); /** * Sends a sync-check to the client: @@ -333,16 +335,16 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_SYNC(Packet &p); + virtual NetworkRecvStatus ReceiveServerSync(Packet &p); /** * Tell the server we are done with this frame: * uint32_t Current frame counter of the client. - * uint8_t The random token that the server sent in the PACKET_SERVER_FRAME packet. + * uint8_t The random token that the server sent in the PacketGameType::ServerFrame packet. * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_ACK(Packet &p); + virtual NetworkRecvStatus ReceiveClientAck(Packet &p); /** * Send a DoCommand to the Server: @@ -354,7 +356,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_COMMAND(Packet &p); + virtual NetworkRecvStatus ReceiveClientCommand(Packet &p); /** * Sends a DoCommand to the client: @@ -367,7 +369,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_COMMAND(Packet &p); + virtual NetworkRecvStatus ReceiveServerCommand(Packet &p); /** * Sends a chat-packet to the server: @@ -379,7 +381,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_CHAT(Packet &p); + virtual NetworkRecvStatus ReceiveClientChat(Packet &p); /** * Sends a chat-packet to the client: @@ -390,7 +392,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_CHAT(Packet &p); + virtual NetworkRecvStatus ReceiveServerChat(Packet &p); /** * Sends a chat-packet for external source to the client: @@ -401,7 +403,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_EXTERNAL_CHAT(Packet &p); + virtual NetworkRecvStatus ReceiveServerExternalChat(Packet &p); /** * Gives the client a new name: @@ -409,14 +411,14 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_SET_NAME(Packet &p); + virtual NetworkRecvStatus ReceiveClientSetName(Packet &p); /** * The client is quitting the game. * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_QUIT(Packet &p); + virtual NetworkRecvStatus ReceiveClientQuit(Packet &p); /** * The client made an error and is quitting the game. @@ -424,7 +426,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_ERROR(Packet &p); + virtual NetworkRecvStatus ReceiveClientError(Packet &p); /** * Notification that a client left the game: @@ -432,7 +434,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_QUIT(Packet &p); + virtual NetworkRecvStatus ReceiveServerQuit(Packet &p); /** * Inform all clients that one client made an error and thus has quit/been disconnected: @@ -441,21 +443,21 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_ERROR_QUIT(Packet &p); + virtual NetworkRecvStatus ReceiveServerErrorQuit(Packet &p); /** * Let the clients know that the server is closing. * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_SHUTDOWN(Packet &p); + virtual NetworkRecvStatus ReceiveServerShutdown(Packet &p); /** * Let the clients know that the server is loading a new map. * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_NEWGAME(Packet &p); + virtual NetworkRecvStatus ReceiveServerNewGame(Packet &p); /** * Send the result of an issues RCon command back to the client: @@ -464,7 +466,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_RCON(Packet &p); + virtual NetworkRecvStatus ReceiveServerRemoteConsoleCommand(Packet &p); /** * Send an RCon command to the server: @@ -473,7 +475,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_RCON(Packet &p); + virtual NetworkRecvStatus ReceiveClientRemoteConsoleCommand(Packet &p); /** * Sends information about all used GRFs to the client: @@ -483,14 +485,14 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_CHECK_NEWGRFS(Packet &p); + virtual NetworkRecvStatus ReceiveServerCheckNewGRFs(Packet &p); /** * Tell the server that we have the required GRFs * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_NEWGRFS_CHECKED(Packet &p); + virtual NetworkRecvStatus ReceiveClientNewGRFsChecked(Packet &p); /** * Move a client from one company into another: @@ -499,7 +501,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_MOVE(Packet &p); + virtual NetworkRecvStatus ReceiveServerMove(Packet &p); /** * Request the server to move this client into another company: @@ -507,7 +509,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_CLIENT_MOVE(Packet &p); + virtual NetworkRecvStatus ReceiveClientMove(Packet &p); /** * Update the clients knowledge of the max settings: @@ -516,7 +518,7 @@ protected: * @param p The packet that was just received. * @return The state the network should have. */ - virtual NetworkRecvStatus Receive_SERVER_CONFIG_UPDATE(Packet &p); + virtual NetworkRecvStatus ReceiveServerConfigurationUpdate(Packet &p); NetworkRecvStatus HandlePacket(Packet &p); diff --git a/src/network/network_client.cpp b/src/network/network_client.cpp index f5d493b7ce..83d17e329e 100644 --- a/src/network/network_client.cpp +++ b/src/network/network_client.cpp @@ -294,7 +294,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendJoin() _network_join_status = NetworkJoinStatus::Authorizing; SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN); - auto p = std::make_unique(my_client, PACKET_CLIENT_JOIN); + auto p = std::make_unique(my_client, PacketGameType::ClientJoin); p->Send_string(GetNetworkRevisionString()); p->Send_uint32(_openttd_newgrf_version); my_client->SendPacket(std::move(p)); @@ -310,7 +310,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendIdentify() { Debug(net, 9, "Client::SendIdentify()"); - auto p = std::make_unique(my_client, PACKET_CLIENT_IDENTIFY); + auto p = std::make_unique(my_client, PacketGameType::ClientIdentify); p->Send_string(_settings_client.network.client_name); // Client name p->Send_uint8(_network_join.company); // PlayAs my_client->SendPacket(std::move(p)); @@ -325,7 +325,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendNewGRFsOk() { Debug(net, 9, "Client::SendNewGRFsOk()"); - auto p = std::make_unique(my_client, PACKET_CLIENT_NEWGRFS_CHECKED); + auto p = std::make_unique(my_client, PacketGameType::ClientNewGRFsChecked); my_client->SendPacket(std::move(p)); return NETWORK_RECV_STATUS_OKAY; } @@ -338,7 +338,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendAuthResponse() { Debug(net, 9, "Client::SendAuthResponse()"); - auto p = std::make_unique(my_client, PACKET_CLIENT_AUTH_RESPONSE); + auto p = std::make_unique(my_client, PacketGameType::ClientAuthenticationResponse); my_client->authentication_handler->SendResponse(*p); my_client->SendPacket(std::move(p)); @@ -356,7 +356,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendGetMap() Debug(net, 9, "Client::status = MAP_WAIT"); my_client->status = STATUS_MAP_WAIT; - auto p = std::make_unique(my_client, PACKET_CLIENT_GETMAP); + auto p = std::make_unique(my_client, PacketGameType::ClientGetMap); my_client->SendPacket(std::move(p)); return NETWORK_RECV_STATUS_OKAY; } @@ -372,7 +372,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendMapOk() Debug(net, 9, "Client::status = ACTIVE"); my_client->status = STATUS_ACTIVE; - auto p = std::make_unique(my_client, PACKET_CLIENT_MAP_OK); + auto p = std::make_unique(my_client, PacketGameType::ClientMapOk); my_client->SendPacket(std::move(p)); return NETWORK_RECV_STATUS_OKAY; } @@ -385,7 +385,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendAck() { Debug(net, 9, "Client::SendAck()"); - auto p = std::make_unique(my_client, PACKET_CLIENT_ACK); + auto p = std::make_unique(my_client, PacketGameType::ClientAck); p->Send_uint32(_frame_counter); p->Send_uint8 (my_client->token); @@ -402,7 +402,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendCommand(const CommandPacke { Debug(net, 9, "Client::SendCommand(): cmd={}", cp.cmd); - auto p = std::make_unique(my_client, PACKET_CLIENT_COMMAND); + auto p = std::make_unique(my_client, PacketGameType::ClientCommand); my_client->NetworkGameSocketHandler::SendCommand(*p, cp); my_client->SendPacket(std::move(p)); @@ -422,7 +422,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendChat(NetworkAction action, { Debug(net, 9, "Client::SendChat(): action={}, type={}, dest={}", action, type, dest); - auto p = std::make_unique(my_client, PACKET_CLIENT_CHAT); + auto p = std::make_unique(my_client, PacketGameType::ClientChat); p->Send_uint8(to_underlying(action)); p->Send_uint8(to_underlying(type)); @@ -443,7 +443,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendError(NetworkErrorCode err { Debug(net, 9, "Client::SendError(): errorno={}", errorno); - auto p = std::make_unique(my_client, PACKET_CLIENT_ERROR); + auto p = std::make_unique(my_client, PacketGameType::ClientError); p->Send_uint8(to_underlying(errorno)); my_client->SendPacket(std::move(p)); @@ -459,7 +459,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendSetName(const std::string { Debug(net, 9, "Client::SendSetName()"); - auto p = std::make_unique(my_client, PACKET_CLIENT_SET_NAME); + auto p = std::make_unique(my_client, PacketGameType::ClientSetName); p->Send_string(name); my_client->SendPacket(std::move(p)); @@ -474,7 +474,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendQuit() { Debug(net, 9, "Client::SendQuit()"); - auto p = std::make_unique(my_client, PACKET_CLIENT_QUIT); + auto p = std::make_unique(my_client, PacketGameType::ClientQuit); my_client->SendPacket(std::move(p)); return NETWORK_RECV_STATUS_OKAY; @@ -490,7 +490,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendRCon(std::string_view pass { Debug(net, 9, "Client::SendRCon()"); - auto p = std::make_unique(my_client, PACKET_CLIENT_RCON); + auto p = std::make_unique(my_client, PacketGameType::ClientRemoteConsoleCommand); p->Send_string(pass); p->Send_string(command); my_client->SendPacket(std::move(p)); @@ -506,7 +506,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::SendMove(CompanyID company) { Debug(net, 9, "Client::SendMove(): company={}", company); - auto p = std::make_unique(my_client, PACKET_CLIENT_MOVE); + auto p = std::make_unique(my_client, PacketGameType::ClientMove); p->Send_uint8(company); my_client->SendPacket(std::move(p)); return NETWORK_RECV_STATUS_OKAY; @@ -529,9 +529,9 @@ bool ClientNetworkGameSocketHandler::IsConnected() struct LoadFilter; extern bool SafeLoad(const std::string &filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, std::shared_ptr lf); -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_FULL(Packet &) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerFull(Packet &) { - Debug(net, 9, "Client::Receive_SERVER_FULL()"); + Debug(net, 9, "Client::ReceiveServerFull()"); /* We try to join a server which is full */ ShowErrorMessage(GetEncodedString(STR_NETWORK_ERROR_SERVER_FULL), {}, WL_CRITICAL); @@ -539,9 +539,9 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_FULL(Packet &) return NETWORK_RECV_STATUS_SERVER_FULL; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_BANNED(Packet &) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerBanned(Packet &) { - Debug(net, 9, "Client::Receive_SERVER_BANNED()"); + Debug(net, 9, "Client::ReceiveServerBanned()"); /* We try to join a server where we are banned */ ShowErrorMessage(GetEncodedString(STR_NETWORK_ERROR_SERVER_BANNED), {}, WL_CRITICAL); @@ -552,13 +552,13 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_BANNED(Packet & /* This packet contains info about the client (playas and name) * as client we save this in NetworkClientInfo, linked via 'client_id' * which is always an unique number on a server. */ -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CLIENT_INFO(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerClientInfo(Packet &p) { NetworkClientInfo *ci; ClientID client_id = (ClientID)p.Recv_uint32(); CompanyID playas = (CompanyID)p.Recv_uint8(); - Debug(net, 9, "Client::Receive_SERVER_CLIENT_INFO(): client_id={}, playas={}", client_id, playas); + Debug(net, 9, "Client::ReceiveServerClientInfo(): client_id={}, playas={}", client_id, playas); std::string name = p.Recv_string(NETWORK_NAME_LENGTH); std::string public_key = p.Recv_string(NETWORK_PUBLIC_KEY_LENGTH); @@ -653,10 +653,10 @@ static StringID GetLongNetworkErrorString(NetworkErrorCode error) } } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_ERROR(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerError(Packet &p) { NetworkErrorCode error = static_cast(p.Recv_uint8()); - Debug(net, 9, "Client::Receive_SERVER_ERROR(): error={}", error); + Debug(net, 9, "Client::ReceiveServerError(): error={}", error); StringID err = GetLongNetworkErrorString(error); /* In case of kicking a client, we assume there is a kick message in the packet if we can read one byte */ @@ -674,14 +674,14 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_ERROR(Packet &p return NETWORK_RECV_STATUS_SERVER_ERROR; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CHECK_NEWGRFS(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerCheckNewGRFs(Packet &p) { if (this->status != STATUS_ENCRYPTED) return NETWORK_RECV_STATUS_MALFORMED_PACKET; uint grf_count = p.Recv_uint8(); NetworkRecvStatus ret = NETWORK_RECV_STATUS_OKAY; - Debug(net, 9, "Client::Receive_SERVER_CHECK_NEWGRFS(): grf_count={}", grf_count); + Debug(net, 9, "Client::ReceiveServerCheckNewGRFs(): grf_count={}", grf_count); /* Check all GRFs */ for (; grf_count > 0; grf_count--) { @@ -720,13 +720,13 @@ class ClientGamePasswordRequestHandler : public NetworkAuthenticationPasswordReq } }; -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_AUTH_REQUEST(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerAuthenticationRequest(Packet &p) { if (this->status != STATUS_JOIN && this->status != STATUS_AUTH_GAME) return NETWORK_RECV_STATUS_MALFORMED_PACKET; Debug(net, 9, "Client::status = AUTH_GAME"); this->status = STATUS_AUTH_GAME; - Debug(net, 9, "Client::Receive_SERVER_AUTH_REQUEST()"); + Debug(net, 9, "Client::ReceiveServerAuthenticationRequest()"); if (this->authentication_handler == nullptr) { this->authentication_handler = NetworkAuthenticationClientHandler::Create(std::make_shared(), @@ -745,11 +745,11 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_AUTH_REQUEST(Pa } } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_ENABLE_ENCRYPTION(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerEnableEncryption(Packet &p) { if (this->status != STATUS_AUTH_GAME || this->authentication_handler == nullptr) return NETWORK_RECV_STATUS_MALFORMED_PACKET; - Debug(net, 9, "Client::Receive_SERVER_ENABLE_ENCRYPTION()"); + Debug(net, 9, "Client::ReceiveServerEnableEncryption()"); if (!this->authentication_handler->ReceiveEnableEncryption(p)) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -763,7 +763,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_ENABLE_ENCRYPTI return this->SendIdentify(); } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_WELCOME(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerWelcome(Packet &p) { if (this->status < STATUS_ENCRYPTED || this->status >= STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET; Debug(net, 9, "Client::status = AUTHORIZED"); @@ -771,18 +771,18 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_WELCOME(Packet _network_own_client_id = (ClientID)p.Recv_uint32(); - Debug(net, 9, "Client::Receive_SERVER_WELCOME(): client_id={}", _network_own_client_id); + Debug(net, 9, "Client::ReceiveServerWelcome(): client_id={}", _network_own_client_id); /* Start receiving the map */ return SendGetMap(); } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_WAIT(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerWaitForMap(Packet &p) { /* We set the internal wait state when requesting the map. */ if (this->status != STATUS_MAP_WAIT) return NETWORK_RECV_STATUS_MALFORMED_PACKET; - Debug(net, 9, "Client::Receive_SERVER_WAIT()"); + Debug(net, 9, "Client::ReceiveServerWaitForMap()"); /* But... only now we set the join status to waiting, instead of requesting. */ Debug(net, 9, "Client::join_status = Waiting"); @@ -793,7 +793,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_WAIT(Packet &p) return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_BEGIN(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerMapBegin(Packet &p) { if (this->status < STATUS_AUTHORIZED || this->status >= STATUS_MAP) return NETWORK_RECV_STATUS_MALFORMED_PACKET; Debug(net, 9, "Client::status = MAP"); @@ -805,7 +805,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_BEGIN(Packe _frame_counter = _frame_counter_server = _frame_counter_max = p.Recv_uint32(); - Debug(net, 9, "Client::Receive_SERVER_MAP_BEGIN(): frame_counter={}", _frame_counter); + Debug(net, 9, "Client::ReceiveServerMapBegin(): frame_counter={}", _frame_counter); _network_join_bytes = 0; _network_join_bytes_total = 0; @@ -817,7 +817,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_BEGIN(Packe return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_SIZE(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerMapSize(Packet &p) { if (this->status != STATUS_MAP) return NETWORK_RECV_STATUS_MALFORMED_PACKET; if (this->savegame == nullptr) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -825,12 +825,12 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_SIZE(Packet _network_join_bytes_total = p.Recv_uint32(); SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN); - Debug(net, 9, "Client::Receive_SERVER_MAP_SIZE(): bytes_total={}", _network_join_bytes_total); + Debug(net, 9, "Client::ReceiveServerMapSize(): bytes_total={}", _network_join_bytes_total); return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_DATA(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerMapData(Packet &p) { if (this->status != STATUS_MAP) return NETWORK_RECV_STATUS_MALFORMED_PACKET; if (this->savegame == nullptr) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -844,12 +844,12 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_DATA(Packet return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_DONE(Packet &) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerMapDone(Packet &) { if (this->status != STATUS_MAP) return NETWORK_RECV_STATUS_MALFORMED_PACKET; if (this->savegame == nullptr) return NETWORK_RECV_STATUS_MALFORMED_PACKET; - Debug(net, 9, "Client::Receive_SERVER_MAP_DONE()"); + Debug(net, 9, "Client::ReceiveServerMapDone()"); Debug(net, 9, "Client::join_status = Processing"); _network_join_status = NetworkJoinStatus::Processing; @@ -908,7 +908,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_DONE(Packet return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_FRAME(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerFrame(Packet &p) { if (this->status != STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -943,7 +943,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_FRAME(Packet &p return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_SYNC(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerSync(Packet &p) { if (this->status != STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -953,12 +953,12 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_SYNC(Packet &p) _sync_seed_2 = p.Recv_uint32(); #endif - Debug(net, 9, "Client::Receive_SERVER_SYNC(): sync_frame={}, sync_seed_1={}", _sync_frame, _sync_seed_1); + Debug(net, 9, "Client::ReceiveServerSync(): sync_frame={}, sync_seed_1={}", _sync_frame, _sync_seed_1); return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_COMMAND(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerCommand(Packet &p) { if (this->status != STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -967,7 +967,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_COMMAND(Packet cp.frame = p.Recv_uint32(); cp.my_cmd = p.Recv_bool(); - Debug(net, 9, "Client::Receive_SERVER_COMMAND(): cmd={}, frame={}", cp.cmd, cp.frame); + Debug(net, 9, "Client::ReceiveServerCommand(): cmd={}, frame={}", cp.cmd, cp.frame); if (err.has_value()) { IConsolePrint(CC_WARNING, "Dropping server connection due to {}.", *err); @@ -979,7 +979,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_COMMAND(Packet return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CHAT(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerChat(Packet &p) { if (this->status != STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -992,7 +992,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CHAT(Packet &p) std::string msg = p.Recv_string(NETWORK_CHAT_LENGTH); int64_t data = p.Recv_uint64(); - Debug(net, 9, "Client::Receive_SERVER_CHAT(): action={}, client_id={}, self_send={}", action, client_id, self_send); + Debug(net, 9, "Client::ReceiveServerChat(): action={}, client_id={}, self_send={}", action, client_id, self_send); ci_to = NetworkClientInfo::GetByClientID(client_id); if (ci_to == nullptr) return NETWORK_RECV_STATUS_OKAY; @@ -1029,7 +1029,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CHAT(Packet &p) return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_EXTERNAL_CHAT(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerExternalChat(Packet &p) { if (this->status != STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -1038,7 +1038,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_EXTERNAL_CHAT(P std::string user = p.Recv_string(NETWORK_CHAT_LENGTH); std::string msg = p.Recv_string(NETWORK_CHAT_LENGTH); - Debug(net, 9, "Client::Receive_SERVER_EXTERNAL_CHAT(): source={}", source); + Debug(net, 9, "Client::ReceiveServerExternalChat(): source={}", source); if (!IsValidConsoleColour(colour)) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -1047,13 +1047,13 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_EXTERNAL_CHAT(P return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_ERROR_QUIT(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerErrorQuit(Packet &p) { if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET; ClientID client_id = (ClientID)p.Recv_uint32(); - Debug(net, 9, "Client::Receive_SERVER_ERROR_QUIT(): client_id={}", client_id); + Debug(net, 9, "Client::ReceiveServerErrorQuit(): client_id={}", client_id); NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id); if (ci != nullptr) { @@ -1066,13 +1066,13 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_ERROR_QUIT(Pack return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_QUIT(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerQuit(Packet &p) { if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET; ClientID client_id = (ClientID)p.Recv_uint32(); - Debug(net, 9, "Client::Receive_SERVER_QUIT(): client_id={}", client_id); + Debug(net, 9, "Client::ReceiveServerQuit(): client_id={}", client_id); NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id); if (ci != nullptr) { @@ -1088,13 +1088,13 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_QUIT(Packet &p) return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_JOIN(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerClientJoined(Packet &p) { if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET; ClientID client_id = (ClientID)p.Recv_uint32(); - Debug(net, 9, "Client::Receive_SERVER_JOIN(): client_id={}", client_id); + Debug(net, 9, "Client::ReceiveServerClientJoined(): client_id={}", client_id); NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id); if (ci != nullptr) { @@ -1106,9 +1106,9 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_JOIN(Packet &p) return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_SHUTDOWN(Packet &) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerShutdown(Packet &) { - Debug(net, 9, "Client::Receive_SERVER_SHUTDOWN()"); + Debug(net, 9, "Client::ReceiveServerShutdown()"); /* Only when we're trying to join we really * care about the server shutting down. */ @@ -1121,9 +1121,9 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_SHUTDOWN(Packet return NETWORK_RECV_STATUS_SERVER_ERROR; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_NEWGAME(Packet &) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerNewGame(Packet &) { - Debug(net, 9, "Client::Receive_SERVER_NEWGAME()"); + Debug(net, 9, "Client::ReceiveServerNewGame()"); /* Only when we're trying to join we really * care about the server shutting down. */ @@ -1140,11 +1140,11 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_NEWGAME(Packet return NETWORK_RECV_STATUS_SERVER_ERROR; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_RCON(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerRemoteConsoleCommand(Packet &p) { if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET; - Debug(net, 9, "Client::Receive_SERVER_RCON()"); + Debug(net, 9, "Client::ReceiveServerRemoteConsoleCommand()"); TextColour colour_code = (TextColour)p.Recv_uint16(); if (!IsValidConsoleColour(colour_code)) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -1156,7 +1156,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_RCON(Packet &p) return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MOVE(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerMove(Packet &p) { if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -1164,7 +1164,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MOVE(Packet &p) ClientID client_id = (ClientID)p.Recv_uint32(); CompanyID company_id = (CompanyID)p.Recv_uint8(); - Debug(net, 9, "Client::Receive_SERVER_MOVE(): client_id={}, company_id={}", client_id, company_id); + Debug(net, 9, "Client::ReceiveServerMove(): client_id={}, company_id={}", client_id, company_id); if (client_id == 0) { /* definitely an invalid client id, debug message and do nothing. */ @@ -1186,7 +1186,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MOVE(Packet &p) return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CONFIG_UPDATE(Packet &p) +NetworkRecvStatus ClientNetworkGameSocketHandler::ReceiveServerConfigurationUpdate(Packet &p) { if (this->status < STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET; @@ -1195,7 +1195,7 @@ NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CONFIG_UPDATE(P InvalidateWindowData(WC_CLIENT_LIST, 0); - Debug(net, 9, "Client::Receive_SERVER_CONFIG_UPDATE(): max_companies={}", _network_server_max_companies); + Debug(net, 9, "Client::ReceiveServerConfigurationUpdate(): max_companies={}", _network_server_max_companies); return NETWORK_RECV_STATUS_OKAY; } diff --git a/src/network/network_client.h b/src/network/network_client.h index c2391df1f4..1f504b9568 100644 --- a/src/network/network_client.h +++ b/src/network/network_client.h @@ -41,32 +41,32 @@ protected: friend void NetworkClose(bool close_admins); static ClientNetworkGameSocketHandler *my_client; ///< This is us! - NetworkRecvStatus Receive_SERVER_FULL(Packet &p) override; - NetworkRecvStatus Receive_SERVER_BANNED(Packet &p) override; - NetworkRecvStatus Receive_SERVER_ERROR(Packet &p) override; - NetworkRecvStatus Receive_SERVER_CLIENT_INFO(Packet &p) override; - NetworkRecvStatus Receive_SERVER_AUTH_REQUEST(Packet &p) override; - NetworkRecvStatus Receive_SERVER_ENABLE_ENCRYPTION(Packet &p) override; - NetworkRecvStatus Receive_SERVER_WELCOME(Packet &p) override; - NetworkRecvStatus Receive_SERVER_WAIT(Packet &p) override; - NetworkRecvStatus Receive_SERVER_MAP_BEGIN(Packet &p) override; - NetworkRecvStatus Receive_SERVER_MAP_SIZE(Packet &p) override; - NetworkRecvStatus Receive_SERVER_MAP_DATA(Packet &p) override; - NetworkRecvStatus Receive_SERVER_MAP_DONE(Packet &p) override; - NetworkRecvStatus Receive_SERVER_JOIN(Packet &p) override; - NetworkRecvStatus Receive_SERVER_FRAME(Packet &p) override; - NetworkRecvStatus Receive_SERVER_SYNC(Packet &p) override; - NetworkRecvStatus Receive_SERVER_COMMAND(Packet &p) override; - NetworkRecvStatus Receive_SERVER_CHAT(Packet &p) override; - NetworkRecvStatus Receive_SERVER_EXTERNAL_CHAT(Packet &p) override; - NetworkRecvStatus Receive_SERVER_QUIT(Packet &p) override; - NetworkRecvStatus Receive_SERVER_ERROR_QUIT(Packet &p) override; - NetworkRecvStatus Receive_SERVER_SHUTDOWN(Packet &p) override; - NetworkRecvStatus Receive_SERVER_NEWGAME(Packet &p) override; - NetworkRecvStatus Receive_SERVER_RCON(Packet &p) override; - NetworkRecvStatus Receive_SERVER_CHECK_NEWGRFS(Packet &p) override; - NetworkRecvStatus Receive_SERVER_MOVE(Packet &p) override; - NetworkRecvStatus Receive_SERVER_CONFIG_UPDATE(Packet &p) override; + NetworkRecvStatus ReceiveServerFull(Packet &p) override; + NetworkRecvStatus ReceiveServerBanned(Packet &p) override; + NetworkRecvStatus ReceiveServerError(Packet &p) override; + NetworkRecvStatus ReceiveServerClientInfo(Packet &p) override; + NetworkRecvStatus ReceiveServerAuthenticationRequest(Packet &p) override; + NetworkRecvStatus ReceiveServerEnableEncryption(Packet &p) override; + NetworkRecvStatus ReceiveServerWelcome(Packet &p) override; + NetworkRecvStatus ReceiveServerWaitForMap(Packet &p) override; + NetworkRecvStatus ReceiveServerMapBegin(Packet &p) override; + NetworkRecvStatus ReceiveServerMapSize(Packet &p) override; + NetworkRecvStatus ReceiveServerMapData(Packet &p) override; + NetworkRecvStatus ReceiveServerMapDone(Packet &p) override; + NetworkRecvStatus ReceiveServerClientJoined(Packet &p) override; + NetworkRecvStatus ReceiveServerFrame(Packet &p) override; + NetworkRecvStatus ReceiveServerSync(Packet &p) override; + NetworkRecvStatus ReceiveServerCommand(Packet &p) override; + NetworkRecvStatus ReceiveServerChat(Packet &p) override; + NetworkRecvStatus ReceiveServerExternalChat(Packet &p) override; + NetworkRecvStatus ReceiveServerQuit(Packet &p) override; + NetworkRecvStatus ReceiveServerErrorQuit(Packet &p) override; + NetworkRecvStatus ReceiveServerShutdown(Packet &p) override; + NetworkRecvStatus ReceiveServerNewGame(Packet &p) override; + NetworkRecvStatus ReceiveServerRemoteConsoleCommand(Packet &p) override; + NetworkRecvStatus ReceiveServerCheckNewGRFs(Packet &p) override; + NetworkRecvStatus ReceiveServerMove(Packet &p) override; + NetworkRecvStatus ReceiveServerConfigurationUpdate(Packet &p) override; static NetworkRecvStatus SendNewGRFsOk(); static NetworkRecvStatus SendGetMap(); diff --git a/src/network/network_query.cpp b/src/network/network_query.cpp index 95c1523fc4..6b497d5451 100644 --- a/src/network/network_query.cpp +++ b/src/network/network_query.cpp @@ -83,13 +83,13 @@ NetworkRecvStatus QueryNetworkGameSocketHandler::SendGameInfo() { Debug(net, 9, "Query::SendGameInfo()"); - this->SendPacket(std::make_unique(this, PACKET_CLIENT_GAME_INFO)); + this->SendPacket(std::make_unique(this, PacketGameType::ClientGameInfo)); return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus QueryNetworkGameSocketHandler::Receive_SERVER_FULL(Packet &) +NetworkRecvStatus QueryNetworkGameSocketHandler::ReceiveServerFull(Packet &) { - Debug(net, 9, "Query::Receive_SERVER_FULL()"); + Debug(net, 9, "Query::ReceiveServerFull()"); NetworkGame *item = NetworkGameListAddItem(this->connection_string); item->status = NGLS_FULL; @@ -100,9 +100,9 @@ NetworkRecvStatus QueryNetworkGameSocketHandler::Receive_SERVER_FULL(Packet &) return NETWORK_RECV_STATUS_CLOSE_QUERY; } -NetworkRecvStatus QueryNetworkGameSocketHandler::Receive_SERVER_BANNED(Packet &) +NetworkRecvStatus QueryNetworkGameSocketHandler::ReceiveServerBanned(Packet &) { - Debug(net, 9, "Query::Receive_SERVER_BANNED()"); + Debug(net, 9, "Query::ReceiveServerBanned()"); NetworkGame *item = NetworkGameListAddItem(this->connection_string); item->status = NGLS_BANNED; @@ -113,9 +113,9 @@ NetworkRecvStatus QueryNetworkGameSocketHandler::Receive_SERVER_BANNED(Packet &) return NETWORK_RECV_STATUS_CLOSE_QUERY; } -NetworkRecvStatus QueryNetworkGameSocketHandler::Receive_SERVER_GAME_INFO(Packet &p) +NetworkRecvStatus QueryNetworkGameSocketHandler::ReceiveServerGameInfo(Packet &p) { - Debug(net, 9, "Query::Receive_SERVER_GAME_INFO()"); + Debug(net, 9, "Query::ReceiveServerGameInfo()"); NetworkGame *item = NetworkGameListAddItem(this->connection_string); @@ -134,11 +134,11 @@ NetworkRecvStatus QueryNetworkGameSocketHandler::Receive_SERVER_GAME_INFO(Packet return NETWORK_RECV_STATUS_CLOSE_QUERY; } -NetworkRecvStatus QueryNetworkGameSocketHandler::Receive_SERVER_ERROR(Packet &p) +NetworkRecvStatus QueryNetworkGameSocketHandler::ReceiveServerError(Packet &p) { NetworkErrorCode error = static_cast(p.Recv_uint8()); - Debug(net, 9, "Query::Receive_SERVER_ERROR(): error={}", error); + Debug(net, 9, "Query::ReceiveServerError(): error={}", error); NetworkGame *item = NetworkGameListAddItem(this->connection_string); diff --git a/src/network/network_query.h b/src/network/network_query.h index db2b1fbf70..93a76911ca 100644 --- a/src/network/network_query.h +++ b/src/network/network_query.h @@ -19,10 +19,10 @@ private: std::string connection_string; ///< Address we are connected to. protected: - NetworkRecvStatus Receive_SERVER_FULL(Packet &p) override; - NetworkRecvStatus Receive_SERVER_BANNED(Packet &p) override; - NetworkRecvStatus Receive_SERVER_ERROR(Packet &p) override; - NetworkRecvStatus Receive_SERVER_GAME_INFO(Packet &p) override; + NetworkRecvStatus ReceiveServerFull(Packet &p) override; + NetworkRecvStatus ReceiveServerBanned(Packet &p) override; + NetworkRecvStatus ReceiveServerError(Packet &p) override; + NetworkRecvStatus ReceiveServerGameInfo(Packet &p) override; NetworkRecvStatus SendGameInfo(); diff --git a/src/network/network_server.cpp b/src/network/network_server.cpp index cbf0549904..ed27c48975 100644 --- a/src/network/network_server.cpp +++ b/src/network/network_server.cpp @@ -56,7 +56,7 @@ NetworkClientSocketPool _networkclientsocket_pool{"NetworkClientSocket"}; INSTANTIATE_POOL_METHODS(NetworkClientSocket) /** Instantiate the listen sockets. */ -template SocketList TCPListenHandler::sockets; +template SocketList TCPListenHandler::sockets; static NetworkAuthenticationDefaultPasswordProvider _password_provider{_settings_client.network.server_password}; ///< Provides the password validation for the game's password. static NetworkAuthenticationDefaultAuthorizedKeyHandler _authorized_key_handler{_settings_client.network.server_authorized_keys}; ///< Provides the authorized key handling for the game authentication. @@ -131,7 +131,7 @@ struct PacketWriter : SaveFilter { std::lock_guard lock(this->mutex); while (!this->packets.empty()) { - bool last_packet = this->packets.front()->GetPacketType() == PACKET_SERVER_MAP_DONE; + bool last_packet = this->packets.front()->GetPacketType() == to_underlying(PacketGameType::ServerMapDone); this->cs->SendPacket(std::move(this->packets.front())); this->packets.pop_front(); @@ -148,7 +148,7 @@ struct PacketWriter : SaveFilter { /* We want to abort the saving when the socket is closed. */ if (this->cs == nullptr) SlError(STR_NETWORK_ERROR_LOSTCONNECTION); - if (this->current == nullptr) this->current = std::make_unique(this->cs, PACKET_SERVER_MAP_DATA, TCP_MTU); + if (this->current == nullptr) this->current = std::make_unique(this->cs, PacketGameType::ServerMapData, TCP_MTU); std::span to_write(buf, size); while (!to_write.empty()) { @@ -156,7 +156,7 @@ struct PacketWriter : SaveFilter { if (!this->current->CanWriteToPacket(1)) { this->packets.push_back(std::move(this->current)); - if (!to_write.empty()) this->current = std::make_unique(this->cs, PACKET_SERVER_MAP_DATA, TCP_MTU); + if (!to_write.empty()) this->current = std::make_unique(this->cs, PacketGameType::ServerMapData, TCP_MTU); } } @@ -174,10 +174,10 @@ struct PacketWriter : SaveFilter { if (this->current != nullptr) this->packets.push_back(std::move(this->current)); /* Add a packet stating that this is the end to the queue. */ - this->packets.push_back(std::make_unique(this->cs, PACKET_SERVER_MAP_DONE)); + this->packets.push_back(std::make_unique(this->cs, PacketGameType::ServerMapDone)); /* Fast-track the size to the client. */ - auto p = std::make_unique(this->cs, PACKET_SERVER_MAP_SIZE); + auto p = std::make_unique(this->cs, PacketGameType::ServerMapSize); p->Send_uint32((uint32_t)this->total_size); this->packets.push_front(std::move(p)); } @@ -330,7 +330,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendClientInfo(NetworkClientIn Debug(net, 9, "client[{}] SendClientInfo(): client_id={}", this->client_id, ci->client_id); if (ci->client_id != INVALID_CLIENT_ID) { - auto p = std::make_unique(this, PACKET_SERVER_CLIENT_INFO); + auto p = std::make_unique(this, PacketGameType::ServerClientInfo); p->Send_uint32(ci->client_id); p->Send_uint8 (ci->client_playas); p->Send_string(ci->client_name); @@ -349,7 +349,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendGameInfo() { Debug(net, 9, "client[{}] SendGameInfo()", this->client_id); - auto p = std::make_unique(this, PACKET_SERVER_GAME_INFO, TCP_MTU); + auto p = std::make_unique(this, PacketGameType::ServerGameInfo, TCP_MTU); SerializeNetworkGameInfo(*p, GetCurrentNetworkServerGameInfo()); this->SendPacket(std::move(p)); @@ -367,7 +367,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendError(NetworkErrorCode err { Debug(net, 9, "client[{}] SendError(): error={}", this->client_id, error); - auto p = std::make_unique(this, PACKET_SERVER_ERROR); + auto p = std::make_unique(this, PacketGameType::ServerError); p->Send_uint8(to_underlying(error)); if (!reason.empty()) p->Send_string(reason); @@ -426,7 +426,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendNewGRFCheck() return this->SendWelcome(); } - auto p = std::make_unique(this, PACKET_SERVER_CHECK_NEWGRFS, TCP_MTU); + auto p = std::make_unique(this, PacketGameType::ServerCheckNewGRFs, TCP_MTU); uint grf_count = std::ranges::count_if(_grfconfig, [](const auto &c){ return !c->flags.Test(GRFConfigFlag::Static); }); p->Send_uint8 (grf_count); @@ -460,7 +460,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendAuthRequest() this->authentication_handler = NetworkAuthenticationServerHandler::Create(&_password_provider, &_authorized_key_handler); } - auto p = std::make_unique(this, PACKET_SERVER_AUTH_REQUEST); + auto p = std::make_unique(this, PacketGameType::ServerAuthenticationRequest); this->authentication_handler->SendRequest(*p); this->SendPacket(std::move(p)); @@ -478,7 +478,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendEnableEncryption() /* Invalid packet when status is anything but STATUS_AUTH_GAME. */ if (this->status != STATUS_AUTH_GAME) return this->CloseConnection(NETWORK_RECV_STATUS_MALFORMED_PACKET); - auto p = std::make_unique(this, PACKET_SERVER_ENABLE_ENCRYPTION); + auto p = std::make_unique(this, PacketGameType::ServerEnableEncryption); this->authentication_handler->SendEnableEncryption(*p); this->SendPacket(std::move(p)); return NETWORK_RECV_STATUS_OKAY; @@ -503,7 +503,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendWelcome() _network_game_info.clients_on++; - auto p = std::make_unique(this, PACKET_SERVER_WELCOME); + auto p = std::make_unique(this, PacketGameType::ServerWelcome); p->Send_uint32(this->client_id); this->SendPacket(std::move(p)); @@ -533,7 +533,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendWait() if (new_cs->GetInfo()->join_date < this->GetInfo()->join_date || (new_cs->GetInfo()->join_date == this->GetInfo()->join_date && new_cs->client_id < this->client_id)) waiting++; } - auto p = std::make_unique(this, PACKET_SERVER_WAIT); + auto p = std::make_unique(this, PacketGameType::ServerWaitForMap); p->Send_uint8(waiting); this->SendPacket(std::move(p)); return NETWORK_RECV_STATUS_OKAY; @@ -590,7 +590,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendMap() this->savegame = std::make_shared(this); /* Now send the _frame_counter and how many packets are coming */ - auto p = std::make_unique(this, PACKET_SERVER_MAP_BEGIN); + auto p = std::make_unique(this, PacketGameType::ServerMapBegin); p->Send_uint32(_frame_counter); this->SendPacket(std::move(p)); @@ -634,7 +634,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendJoin(ClientID client_id) { Debug(net, 9, "client[{}] SendJoin(): client_id={}", this->client_id, client_id); - auto p = std::make_unique(this, PACKET_SERVER_JOIN); + auto p = std::make_unique(this, PacketGameType::ServerClientJoined); p->Send_uint32(client_id); @@ -648,7 +648,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendJoin(ClientID client_id) */ NetworkRecvStatus ServerNetworkGameSocketHandler::SendFrame() { - auto p = std::make_unique(this, PACKET_SERVER_FRAME); + auto p = std::make_unique(this, PacketGameType::ServerFrame); p->Send_uint32(_frame_counter); p->Send_uint32(_frame_counter_max); #ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME @@ -676,7 +676,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendSync() { Debug(net, 9, "client[{}] SendSync(), frame_counter={}, sync_seed_1={}", this->client_id, _frame_counter, _sync_seed_1); - auto p = std::make_unique(this, PACKET_SERVER_SYNC); + auto p = std::make_unique(this, PacketGameType::ServerSync); p->Send_uint32(_frame_counter); p->Send_uint32(_sync_seed_1); @@ -696,7 +696,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendCommand(const CommandPacke { Debug(net, 9, "client[{}] SendCommand(): cmd={}", this->client_id, cp.cmd); - auto p = std::make_unique(this, PACKET_SERVER_COMMAND); + auto p = std::make_unique(this, PacketGameType::ServerCommand); this->NetworkGameSocketHandler::SendCommand(*p, cp); p->Send_uint32(cp.frame); @@ -721,7 +721,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendChat(NetworkAction action, if (this->status < STATUS_PRE_ACTIVE) return NETWORK_RECV_STATUS_OKAY; - auto p = std::make_unique(this, PACKET_SERVER_CHAT); + auto p = std::make_unique(this, PacketGameType::ServerChat); p->Send_uint8(to_underlying(action)); p->Send_uint32(client_id); @@ -747,7 +747,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendExternalChat(std::string_v if (this->status < STATUS_PRE_ACTIVE) return NETWORK_RECV_STATUS_OKAY; - auto p = std::make_unique(this, PACKET_SERVER_EXTERNAL_CHAT); + auto p = std::make_unique(this, PacketGameType::ServerExternalChat); p->Send_string(source); p->Send_uint16(colour); @@ -768,7 +768,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendErrorQuit(ClientID client_ { Debug(net, 9, "client[{}] SendErrorQuit(): client_id={}, errorno={}", this->client_id, client_id, errorno); - auto p = std::make_unique(this, PACKET_SERVER_ERROR_QUIT); + auto p = std::make_unique(this, PacketGameType::ServerErrorQuit); p->Send_uint32(client_id); p->Send_uint8(to_underlying(errorno)); @@ -786,7 +786,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendQuit(ClientID client_id) { Debug(net, 9, "client[{}] SendQuit(): client_id={}", this->client_id, client_id); - auto p = std::make_unique(this, PACKET_SERVER_QUIT); + auto p = std::make_unique(this, PacketGameType::ServerQuit); p->Send_uint32(client_id); @@ -802,7 +802,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendShutdown() { Debug(net, 9, "client[{}] SendShutdown()", this->client_id); - auto p = std::make_unique(this, PACKET_SERVER_SHUTDOWN); + auto p = std::make_unique(this, PacketGameType::ServerShutdown); this->SendPacket(std::move(p)); return NETWORK_RECV_STATUS_OKAY; } @@ -815,7 +815,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendNewGame() { Debug(net, 9, "client[{}] SendNewGame()", this->client_id); - auto p = std::make_unique(this, PACKET_SERVER_NEWGAME); + auto p = std::make_unique(this, PacketGameType::ServerNewGame); this->SendPacket(std::move(p)); return NETWORK_RECV_STATUS_OKAY; } @@ -830,7 +830,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendRConResult(uint16_t colour { Debug(net, 9, "client[{}] SendRConResult()", this->client_id); - auto p = std::make_unique(this, PACKET_SERVER_RCON); + auto p = std::make_unique(this, PacketGameType::ServerRemoteConsoleCommand); p->Send_uint16(colour); p->Send_string(command); @@ -848,7 +848,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendMove(ClientID client_id, C { Debug(net, 9, "client[{}] SendMove(): client_id={}", this->client_id, client_id); - auto p = std::make_unique(this, PACKET_SERVER_MOVE); + auto p = std::make_unique(this, PacketGameType::ServerMove); p->Send_uint32(client_id); p->Send_uint8(company_id); @@ -864,7 +864,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendConfigUpdate() { Debug(net, 9, "client[{}] SendConfigUpdate()", this->client_id); - auto p = std::make_unique(this, PACKET_SERVER_CONFIG_UPDATE); + auto p = std::make_unique(this, PacketGameType::ServerConfigurationUpdate); p->Send_uint8(_settings_client.network.max_companies); p->Send_string(_settings_client.network.server_name); @@ -876,26 +876,26 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::SendConfigUpdate() * Receiving functions ************/ -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_GAME_INFO(Packet &) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientGameInfo(Packet &) { - Debug(net, 9, "client[{}] Receive_CLIENT_GAME_INFO()", this->client_id); + Debug(net, 9, "client[{}] ReceiveClientGameInfo()", this->client_id); return this->SendGameInfo(); } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_NEWGRFS_CHECKED(Packet &) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientNewGRFsChecked(Packet &) { if (this->status != STATUS_NEWGRFS_CHECK) { /* Illegal call, return error and ignore the packet */ return this->SendError(NetworkErrorCode::NotExpected); } - Debug(net, 9, "client[{}] Receive_CLIENT_NEWGRFS_CHECKED()", this->client_id); + Debug(net, 9, "client[{}] ReceiveClientNewGRFsChecked()", this->client_id); return this->SendWelcome(); } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_JOIN(Packet &p) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientJoin(Packet &p) { if (this->status != STATUS_INACTIVE) { /* Illegal call, return error and ignore the packet */ @@ -910,7 +910,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_JOIN(Packet &p) std::string client_revision = p.Recv_string(NETWORK_REVISION_LENGTH); uint32_t newgrf_version = p.Recv_uint32(); - Debug(net, 9, "client[{}] Receive_CLIENT_JOIN(): client_revision={}, newgrf_version={}", this->client_id, client_revision, newgrf_version); + Debug(net, 9, "client[{}] ReceiveClientJoin(): client_revision={}, newgrf_version={}", this->client_id, client_revision, newgrf_version); /* Check if the client has revision control enabled */ if (!IsNetworkCompatibleVersion(client_revision) || _openttd_newgrf_version != newgrf_version) { @@ -921,11 +921,11 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_JOIN(Packet &p) return this->SendAuthRequest(); } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_IDENTIFY(Packet &p) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientIdentify(Packet &p) { if (this->status != STATUS_IDENTIFY) return this->SendError(NetworkErrorCode::NotExpected); - Debug(net, 9, "client[{}] Receive_CLIENT_IDENTIFY()", this->client_id); + Debug(net, 9, "client[{}] ReceiveClientIdentify()", this->client_id); std::string client_name = p.Recv_string(NETWORK_CLIENT_NAME_LENGTH); CompanyID playas = (Owner)p.Recv_uint8(); @@ -1000,13 +1000,13 @@ static NetworkErrorCode GetErrorForAuthenticationMethod(NetworkAuthenticationMet } } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_AUTH_RESPONSE(Packet &p) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientAuthenticationResponse(Packet &p) { if (this->status != STATUS_AUTH_GAME) { return this->SendError(NetworkErrorCode::NotExpected); } - Debug(net, 9, "client[{}] Receive_CLIENT_AUTH_RESPONSE()", this->client_id); + Debug(net, 9, "client[{}] ReceiveClientAuthenticationResponse()", this->client_id); auto authentication_method = this->authentication_handler->GetAuthenticationMethod(); switch (this->authentication_handler->ReceiveResponse(p)) { @@ -1038,7 +1038,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_AUTH_RESPONSE(P return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_GETMAP(Packet &) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientGetMap(Packet &) { /* The client was never joined.. so this is impossible, right? * Ignore the packet, give the client a warning, and close the connection */ @@ -1046,7 +1046,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_GETMAP(Packet & return this->SendError(NetworkErrorCode::NotAuthorized); } - Debug(net, 9, "client[{}] Receive_CLIENT_GETMAP()", this->client_id); + Debug(net, 9, "client[{}] ReceiveClientGetMap()", this->client_id); /* Check if someone else is receiving the map */ for (NetworkClientSocket *new_cs : NetworkClientSocket::Iterate()) { @@ -1062,11 +1062,11 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_GETMAP(Packet & return this->SendMap(); } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_MAP_OK(Packet &) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientMapOk(Packet &) { /* Client has the map, now start syncing */ if (this->status == STATUS_DONE_MAP && !this->HasClientQuit()) { - Debug(net, 9, "client[{}] Receive_CLIENT_MAP_OK()", this->client_id); + Debug(net, 9, "client[{}] ReceiveClientMapOk()", this->client_id); std::string client_name = this->GetClientName(); @@ -1105,7 +1105,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_MAP_OK(Packet & return this->SendError(NetworkErrorCode::NotExpected); } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_COMMAND(Packet &p) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientCommand(Packet &p) { /* The client was never joined.. so this is impossible, right? * Ignore the packet, give the client a warning, and close the connection */ @@ -1117,7 +1117,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_COMMAND(Packet return this->SendError(NetworkErrorCode::TooManyCommands); } - Debug(net, 9, "client[{}] Receive_CLIENT_COMMAND()", this->client_id); + Debug(net, 9, "client[{}] ReceiveClientCommand()", this->client_id); CommandPacket cp; auto err = this->ReceiveCommand(p, cp); @@ -1191,13 +1191,13 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_COMMAND(Packet return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_ERROR(Packet &p) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientError(Packet &p) { /* This packets means a client noticed an error and is reporting this * to us. Display the error and report it to the other clients */ NetworkErrorCode errorno = static_cast(p.Recv_uint8()); - Debug(net, 9, "client[{}] Receive_CLIENT_ERROR(): errorno={}", this->client_id, errorno); + Debug(net, 9, "client[{}] ReceiveClientError(): errorno={}", this->client_id, errorno); /* The client was never joined.. thank the client for the packet, but ignore it */ if (this->status < STATUS_DONE_MAP || this->HasClientQuit()) { @@ -1222,14 +1222,14 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_ERROR(Packet &p return this->CloseConnection(NETWORK_RECV_STATUS_CLIENT_QUIT); } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_QUIT(Packet &) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientQuit(Packet &) { /* The client was never joined.. thank the client for the packet, but ignore it */ if (this->status < STATUS_DONE_MAP || this->HasClientQuit()) { return this->CloseConnection(NETWORK_RECV_STATUS_CLIENT_QUIT); } - Debug(net, 9, "client[{}] Receive_CLIENT_QUIT()", this->client_id); + Debug(net, 9, "client[{}] ReceiveClientQuit()", this->client_id); /* The client wants to leave. Display this and report it to the other clients. */ std::string client_name = this->GetClientName(); @@ -1246,7 +1246,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_QUIT(Packet &) return this->CloseConnection(NETWORK_RECV_STATUS_CLIENT_QUIT); } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_ACK(Packet &p) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientAck(Packet &p) { if (this->status < STATUS_AUTHORIZED) { /* Illegal call, return error and ignore the packet */ @@ -1255,7 +1255,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_ACK(Packet &p) uint32_t frame = p.Recv_uint32(); - Debug(net, 9, "client[{}] Receive_CLIENT_ACK(): frame={}", this->client_id, frame); + Debug(net, 9, "client[{}] ReceiveClientAck(): frame={}", this->client_id, frame); /* The client is trying to catch up with the server */ if (this->status == STATUS_PRE_ACTIVE) { @@ -1277,10 +1277,10 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_ACK(Packet &p) /* We differentiate between last_token_frame and last_frame so the lag * test uses the actual lag of the client instead of the lag for getting * the token back and forth; after all, the token is only sent every - * time we receive a PACKET_CLIENT_ACK, after which we will send a new + * time we receive a PacketGameType::ClientAck, after which we will send a new * token to the client. If the lag would be one day, then we would not * be sending the new token soon enough for the new daily scheduled - * PACKET_CLIENT_ACK. This would then register the lag of the client as + * PacketGameType::ClientAck. This would then register the lag of the client as * two days, even when it's only a single day. */ this->last_token_frame = _frame_counter; /* Request a new token. */ @@ -1430,7 +1430,7 @@ void NetworkServerSendExternalChat(std::string_view source, TextColour colour, s NetworkTextMessage(NetworkAction::ChatExternal, colour, false, user, msg, source); } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_CHAT(Packet &p) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientChat(Packet &p) { if (this->status < STATUS_PRE_ACTIVE) { /* Illegal call, return error and ignore the packet */ @@ -1441,7 +1441,7 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_CHAT(Packet &p) NetworkChatDestinationType desttype = static_cast(p.Recv_uint8()); int dest = p.Recv_uint32(); - Debug(net, 9, "client[{}] Receive_CLIENT_CHAT(): action={}, desttype={}, dest={}", this->client_id, action, desttype, dest); + Debug(net, 9, "client[{}] ReceiveClientChat(): action={}, desttype={}, dest={}", this->client_id, action, desttype, dest); std::string msg = p.Recv_string(NETWORK_CHAT_LENGTH); int64_t data = p.Recv_uint64(); @@ -1460,14 +1460,14 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_CHAT(Packet &p) return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_SET_NAME(Packet &p) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientSetName(Packet &p) { if (this->status != STATUS_ACTIVE) { /* Illegal call, return error and ignore the packet */ return this->SendError(NetworkErrorCode::NotExpected); } - Debug(net, 9, "client[{}] Receive_CLIENT_SET_NAME()", this->client_id); + Debug(net, 9, "client[{}] ReceiveClientSetName()", this->client_id); NetworkClientInfo *ci; @@ -1494,11 +1494,11 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_SET_NAME(Packet return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_RCON(Packet &p) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientRemoteConsoleCommand(Packet &p) { if (this->status != STATUS_ACTIVE) return this->SendError(NetworkErrorCode::NotExpected); - Debug(net, 9, "client[{}] Receive_CLIENT_RCON()", this->client_id); + Debug(net, 9, "client[{}] ReceiveClientRemoteConsoleCommand()", this->client_id); std::string password = p.Recv_string(NETWORK_PASSWORD_LENGTH); std::string command = p.Recv_string(NETWORK_RCONCOMMAND_LENGTH); @@ -1520,13 +1520,13 @@ NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_RCON(Packet &p) return NETWORK_RECV_STATUS_OKAY; } -NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_MOVE(Packet &p) +NetworkRecvStatus ServerNetworkGameSocketHandler::ReceiveClientMove(Packet &p) { if (this->status != STATUS_ACTIVE) return this->SendError(NetworkErrorCode::NotExpected); CompanyID company_id = (Owner)p.Recv_uint8(); - Debug(net, 9, "client[{}] Receive_CLIENT_MOVE(): company_id={}", this->client_id, company_id); + Debug(net, 9, "client[{}] ReceiveClientMove(): company_id={}", this->client_id, company_id); /* Check if the company is valid, we don't allow moving to AI companies */ if (company_id != COMPANY_SPECTATOR) { diff --git a/src/network/network_server.h b/src/network/network_server.h index f1453b37c6..ea79aa0662 100644 --- a/src/network/network_server.h +++ b/src/network/network_server.h @@ -21,26 +21,26 @@ using NetworkClientSocketPool = Pool, public NetworkGameSocketHandler, public TCPListenHandler { +class ServerNetworkGameSocketHandler : public NetworkClientSocketPool::PoolItem<&_networkclientsocket_pool>, public NetworkGameSocketHandler, public TCPListenHandler { protected: std::unique_ptr authentication_handler = nullptr; ///< The handler for the authentication. std::string peer_public_key{}; ///< The public key of our client. - NetworkRecvStatus Receive_CLIENT_JOIN(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_IDENTIFY(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_GAME_INFO(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_AUTH_RESPONSE(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_GETMAP(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_MAP_OK(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_ACK(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_COMMAND(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_CHAT(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_SET_NAME(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_QUIT(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_ERROR(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_RCON(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_NEWGRFS_CHECKED(Packet &p) override; - NetworkRecvStatus Receive_CLIENT_MOVE(Packet &p) override; + NetworkRecvStatus ReceiveClientJoin(Packet &p) override; + NetworkRecvStatus ReceiveClientIdentify(Packet &p) override; + NetworkRecvStatus ReceiveClientGameInfo(Packet &p) override; + NetworkRecvStatus ReceiveClientAuthenticationResponse(Packet &p) override; + NetworkRecvStatus ReceiveClientGetMap(Packet &p) override; + NetworkRecvStatus ReceiveClientMapOk(Packet &p) override; + NetworkRecvStatus ReceiveClientAck(Packet &p) override; + NetworkRecvStatus ReceiveClientCommand(Packet &p) override; + NetworkRecvStatus ReceiveClientChat(Packet &p) override; + NetworkRecvStatus ReceiveClientSetName(Packet &p) override; + NetworkRecvStatus ReceiveClientQuit(Packet &p) override; + NetworkRecvStatus ReceiveClientError(Packet &p) override; + NetworkRecvStatus ReceiveClientRemoteConsoleCommand(Packet &p) override; + NetworkRecvStatus ReceiveClientNewGRFsChecked(Packet &p) override; + NetworkRecvStatus ReceiveClientMove(Packet &p) override; NetworkRecvStatus SendGameInfo(); NetworkRecvStatus SendNewGRFCheck();